Resource affinity computing power scheduling method and device, equipment and medium

Abstract

The present application relates to a kind of resource affinity power scheduling method, device, equipment and medium based on, including the following steps, the load state data of each computing node is collected by power node monitoring module;Then the task of user submission is carried out demand analysis, generates task resource demand vector, and with node load data affinity matching, obtain resource affinity matching value;Then the interdependence of node is analyzed, and resource dependence coefficient is calculated, and weighted with affinity matching value to obtain comprehensive affinity value;Comprehensive affinity value is sorted in descending order, and form node priority sequence;Finally, power mapping scheduling is carried out based on the sequence, and the final scheduling scheme is generated.The method considers resource matching degree and node collaborative relationship comprehensively, improves scheduling efficiency and resource utilization, solves the technical problems of low resource utilization, high task response delay and uneven load between nodes caused by traditional scheduling method.

Description

Technical Field

[0001] This invention relates to the field of resource affinity technology, and in particular to a method, apparatus, device, and medium for scheduling computing power based on resource affinity. Background Technology

[0002] As computing tasks become increasingly complex and diverse, efficiently scheduling tasks to suitable computing nodes has become a key challenge in the field of computing power scheduling. Traditional scheduling methods, often based on single resource metrics or static priorities, struggle to adapt to dynamically changing load environments and task requirements, leading to low resource utilization, high task response latency, and uneven load distribution among nodes. The aforementioned technical solution, by introducing resource affinity matching, node dependency analysis, and a comprehensive weighted sorting mechanism, aims to address the technical problems of low resource matching, low scheduling efficiency, and unstable task execution performance in existing computing power scheduling methods under dynamic load environments. Summary of the Invention

[0003] The main objective of this invention is to provide a resource affinity-based computing power scheduling method, which solves the technical problems of traditional scheduling methods that are mostly based on a single resource index or static priority, making it difficult to adapt to dynamically changing load environments and task requirements, resulting in low resource utilization, high task response latency, and uneven load among nodes.

[0004] To achieve the above objectives, this invention provides a resource affinity-based computing power scheduling method, comprising the following steps:

[0005] 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.

[0006] 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.

[0007] 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.

[0008] 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.

[0009] Furthermore, the load status data of each computing node in the target device is collected by the computing node monitoring module to obtain node load status data, including:

[0010] 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.

[0011] 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.

[0012] 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.

[0013] Furthermore, the step of parsing the computational tasks submitted by the target user to obtain a task resource requirement vector includes:

[0014] 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.

[0015] Based on the task classification encoding vector, a matching search is performed in a preset resource mapping rule base to obtain the task resource requirement vector.

[0016] Furthermore, 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:

[0017] 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.

[0018] 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.

[0019] 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.

[0020] The resource affinity matching value is obtained by numerically fusing the basic matching coefficient and the comprehensive difference coefficient.

[0021] Furthermore, the step of performing node dependency analysis based on the resource affinity matching value to obtain the resource dependency coefficient includes:

[0022] 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.

[0023] 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.

[0024] 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.

[0025] 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.

[0026] Furthermore, the step of performing path traversal based on the weighted node association graph to extract the shortest dependency path between each computing node includes:

[0027] For each computation node in the weighted node association graph, initialize the path record to obtain an initial path record table;

[0028] 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.

[0029] 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.

[0030] Furthermore, 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:

[0031] 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.

[0032] The resource satisfaction level is obtained by calculating the ratio between the candidate nodes and the task resource requirement vector.

[0033] 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.

[0034] 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.

[0035] The present invention also provides a resource affinity-based computing power scheduling device, comprising:

[0036] 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.

[0037] The parsing module is used to parse the computing tasks submitted by the target user to obtain a task resource requirement vector, and to perform affinity matching on the task resource requirement vector based on the node load status data to obtain a resource affinity matching value.

[0038] 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.

[0039] 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.

[0040] The present invention also provides a computer device, including a memory and a processor, wherein the memory stores a computer program, and the processor executes the computer program to implement the steps of any of the methods described above.

[0041] The present invention also provides a computer-readable storage medium having a computer program stored thereon, wherein the computer program, when executed by a processor, implements the steps of any of the methods described above.

[0042] This invention provides a resource affinity-based computing power scheduling method, comprising the following steps: collecting load status data of each computing node in the target device through a computing node monitoring module; parsing the computing tasks submitted by the target user to obtain a task resource requirement vector, and performing affinity matching on the task resource requirement vector based on the node load status data to obtain a resource affinity matching value; performing node dependency analysis based on the resource affinity matching value to obtain a resource dependency coefficient, and performing a weighted calculation of 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 requirement vector based on the node priority sequence to obtain a computing power scheduling scheme. This method solves the technical problems of traditional scheduling methods, which are mostly based on single resource indicators or static priorities, making it difficult to adapt to dynamically changing load environments and task requirements, resulting in low resource utilization, high task response latency, and uneven load among nodes. It achieves the technical effect of improving resource utilization and effectively reducing task execution latency. Attached Figure Description

[0043] 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.

[0044] 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;

[0045] 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;

[0046] Figure 3 This is a schematic block diagram of the structure of a computer device according to an embodiment of the present invention.

[0047] 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

[0048] 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.

[0049] like Figure 1 As shown, Figure 1This invention provides a resource affinity-based computing power scheduling method, comprising the following steps:

[0050] 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.

[0051] 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.

[0052] 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;

[0053] 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.

[0054] Specifically, this solution proposes a resource affinity-based computing power scheduling method. This method aims to achieve efficient matching between tasks and computing nodes through a systematic resource assessment and scheduling mechanism, thereby improving the overall resource utilization and task execution efficiency of the computing power system. First, in step S1, the system continuously collects real-time load status data of each computing node through a computing node monitoring module deployed in the target device. This module can acquire various resource indicators, including CPU utilization, memory usage, network bandwidth, and I / O throughput, forming a comprehensive understanding of the current resource availability status of the nodes. For example, in a data center computing power scheduling scenario, if a node is running multiple high-concurrency tasks, its CPU and memory resources may be close to saturation, while another node is under low load. The computing node monitoring module can obtain this information in real time, providing basic data support for subsequent scheduling decisions. Next, in step S2, the system performs requirement analysis on the computing tasks submitted by the user, extracting various resource indicators required by the task and constructing a task resource requirement vector. This vector may include the number of CPU cores, memory size, GPU resources, network bandwidth, etc., required by the task. Subsequently, the system performs affinity matching calculations between the task's resource requirement vector and the node load status data obtained in step S1 to assess the resource compatibility between the task and each computing node. For example, if a task has a high demand for GPU computing power, and a node happens to have high-performance GPU resources and its current load is low, then the resource affinity matching value between the node and the task will be high; conversely, if a node's GPU resources are fully loaded, its matching value will be low. This affinity matching mechanism enables the scheduling system to establish a more accurate resource matching relationship between tasks and nodes. Then, in step S3, based on the resource affinity matching value obtained in step S2, the system further analyzes the dependencies between nodes to obtain resource dependency coefficients. In actual computing environments, multiple computing nodes may have resource dependencies, such as some nodes needing frequent communication or sharing storage resources. Ignoring such dependencies may lead to increased communication latency and intensified resource contention after task scheduling. Therefore, the system identifies resource dependencies between nodes by analyzing the trend of resource affinity changes and calculates resource dependency coefficients accordingly. Then, the system performs a weighted calculation of the resource dependency coefficient and the resource affinity matching value from step S2 to obtain a comprehensive affinity value. The significance of this step lies in considering not only the resource matching degree between the task and the node, but also the collaborative efficiency between nodes, thereby improving the overall scheduling rationality and task execution stability. 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 ranking of the adaptability 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.

[0055] 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:

[0056] 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.

[0057] 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.

[0058] 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.

[0059] Specifically, the system first uses a computing node monitoring module to periodically sample each computing node in the target device. For example, it collects resource indicators such as CPU utilization, memory usage, GPU utilization, and network bandwidth usage every second, thus forming raw load time-series data. Taking a typical data center as an example, suppose a node records CPU utilization every second for 30 consecutive seconds, resulting in a data sequence of [45%, 46%, 44%, 50%, 48%, 47%, 95%, 46%, 45%, 47%, …]. At the 7th second, a value significantly higher than other time points (95%) appears. This could be an outlier caused by a sudden surge in tasks or sampling errors. To avoid such outliers interfering with subsequent analysis, the system performs outlier removal processing on the raw load time-series data. For example, it uses a sliding window averaging method or the 3σ principle to remove or replace data points deviating from the normal range with the average of nearby values, thus obtaining preprocessed load time-series data. For instance, replacing 95% at the 7th second in the above sequence with 46% creates a more stable and representative data sequence. Next, the system extracts multi-dimensional features based on the preprocessed load time-series data to more comprehensively characterize the load status of computing nodes. These features may include: instantaneous resource utilization at the current moment, average resource utilization over a recent period, resource utilization fluctuation range (standard deviation), resource utilization trend (such as upward or downward trend), and peak resource utilization. For example, for the preprocessed CPU utilization data of a certain node, the system can extract indicators such as a current instantaneous value of 47%, an average value of 46% over the past 10 seconds, a standard deviation of 1.2%, a stable trend, and a maximum value of 48%, forming multi-dimensional load features. To facilitate subsequent comparison and calculation, the system normalizes these multi-dimensional load features to make them fall within a uniform numerical range (such as between 0 and 1), thus obtaining standardized load features. For example, if the normalized CPU utilization of a certain node is 0.47, the memory utilization is 0.35, and the network bandwidth utilization is 0.28, these values ​​can be used for subsequent multi-node comparison and analysis. Building upon this foundation, the system further performs spatiotemporal correlation analysis on standardized load characteristics to identify the correlation of load changes 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 changing trends of CPU, memory, and other resource usage among the nodes. It finds that the resource usage of node 1 and node 2 exhibits high synchronicity at multiple points in time (e.g., a correlation coefficient of 0.85), while the resource usage of node 3 and node 4 shows a negative correlation (e.g., a correlation coefficient of -0.6), indicating a potential complementary resource relationship between them. Through this analysis, the system can construct a 10×10 node load correlation matrix, where each element represents the strength and direction of the correlation between resource usage between two nodes.Finally, the system fuses the standardized load feature set with the node load correlation matrix to obtain complete node load status data. This fusion process can be understood as combining the load status of a single node with its role in the global network, thus forming a three-dimensional description of the node load status. For example, in the 10-node system mentioned above, 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. In the node load correlation matrix, it shows a high correlation with node 2 and a weak correlation with node 5. 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 comprehensive perception and modeling of the load status of each computing node in the target device, providing a solid data foundation for subsequent resource affinity matching, dependency analysis, and scheduling decisions. Taking deep learning training tasks as an example, this task has high requirements for GPU resources and memory bandwidth and requires multiple nodes to collaborate. After collecting and processing the load status data of each node through the above process, the system can identify which nodes have sufficient GPU resources, which nodes have high communication efficiency, and which nodes currently have a light load, thus providing a scientific basis for task scheduling. For example, if the system finds that node A currently has a GPU load of 0.3 and a memory load of 0.25, and the resource usage correlation coefficient between node A and node B is 0.8, it indicates that they have good coordination. In this case, the system may prioritize assigning the task to node A and schedule its subtasks to node B to achieve dual optimization of resource utilization efficiency and task execution efficiency.

[0060] In a specific embodiment, the step of parsing the computational tasks submitted by the target user to obtain a task resource requirement vector includes:

[0061] 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.

[0062] Based on the task classification encoding vector, a matching search is performed in a preset resource mapping rule base to obtain the task resource requirement vector.

[0063] Specifically, parsing the computational tasks submitted by target users to obtain task resource requirement vectors is a crucial preliminary step for achieving precise computing power scheduling. Its core lies in transforming the unstructured or semi-structured task descriptions submitted by users into quantifiable, system-recognizable resource requirement information. This process first involves parsing the syntactic structure of the descriptive text in the computational task to extract a set of key attribute features. These features may include task type (e.g., image processing, machine learning training, data encryption), expected execution time, input data size, required software environment, and whether specific hardware acceleration (e.g., GPU, FPGA) is needed. Syntactic structure parsing typically relies on natural language processing techniques, such as dependency parsing and named entity recognition, 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 perform syntactic parsing on this text, recognizing that "real-time" indicates low latency requirements, "high-definition video stream" implies high bandwidth and large memory requirements, and "license plate recognition" is associated with image processing and deep learning model inference, thus forming a set of task attribute features containing these dimensions. Based on this, the system further performs task classification encoding on the computational task according to the set of task attribute features, generating a task classification encoding vector. This encoding process typically uses a pre-trained classification model or rule engine to map the extracted task attributes to a predefined task category space. For example, "license plate recognition" is classified as "computer vision - object detection," and a corresponding encoding value is assigned, ultimately forming a numerical task classification encoding vector. This vector not only preserves the semantic category information of the task but also provides structured input for subsequent resource mapping. Next, the system uses the task classification encoding vector to perform a matching search in a preset resource mapping rule base. This rule base stores the mapping relationship between various task classification codes and their typical resource consumption patterns. For example, a task like "computer vision - object detection" typically requires at least a 4-core CPU, 16GB of memory, and a medium-power GPU. Through matching and searching, the system can automatically obtain the resource configuration template that best matches the current task, i.e., the task resource requirement vector. This vector specifically quantifies the required number of CPU cores, memory capacity, GPU computing power, storage I / O, and network bandwidth, among other indicators.Therefore, when the aforementioned intelligent transportation system receives the "real-time high-definition video stream license plate recognition task," it obtains relevant features through syntax parsing and attribute extraction, and then generates a corresponding task classification encoding vector through classification encoding. The system searches for matching entries in the resource mapping rule base and finally outputs a specific task resource requirement vector, such as [CPU: 6 cores, memory: 24GB, GPU: 1 block (computing power ≥10 TFLOPS), network bandwidth: ≥100Mbps]. This provides accurate input basis for subsequent similarity matching with node resource features and calculation of initial values ​​of resource affinity, thereby ensuring that scheduling decisions not only meet the actual needs of the task but also make full use of the underlying computing resources.

[0064] In a specific embodiment, 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:

[0065] 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.

[0066] 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.

[0067] 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.

[0068] The resource affinity matching value is obtained by numerically fusing the basic matching coefficient and the comprehensive difference coefficient; wherein the resource affinity matching value ranges from [0,1], and the larger the value, the higher the resource affinity between the computing node and the computing task.

[0069] Specifically, after completing the collection of node load status data and the generation of task resource demand vectors, the system first extracts dimensions from the node load status data, extracting resource dimensions corresponding to the task resource demand vectors, such as CPU utilization, GPU computing power, memory usage, network bandwidth, and I / O throughput, to form a node dimension vector. For example, in a data center scheduling scenario, if the task resource demand vector contains five dimensions: GPU computing power (TFLOPS), memory capacity (GB), CPU utilization (%), network bandwidth (Gbps), and I / O throughput (MB / s), the system extracts the corresponding dimensions from the node load status data to form a node dimension vector, such as [18, 28, 45, 0.9, 480], indicating that the node currently has a GPU computing power of 18 TFLOPS, 28 GB of memory remaining, a CPU utilization of 45%, a network bandwidth of 0.9 Gbps, and an I / O throughput of 480 MB / s. To ensure resource dimension consistency between tasks and nodes, the system performs dimension alignment on the task resource requirement vector and the node dimension vector, forming a set of feature vectors with the same dimension. For example, if the task resource requirement vector is [20, 32, 50, 1.2, 600], then the aligned set of feature vectors with the same dimension represents a one-to-one correspondence between the task resource requirement vector and the node dimension vector. Based on this, the system further vectorizes the node dimension vector as the node load state vector and calculates the cosine similarity between the task resource requirement vector and the node load state vector based on the set of feature vectors with the same dimension, thus obtaining the basic matching coefficient. Cosine similarity is an index that measures the similarity of the directions of two vectors, with a value range of [-1, 1]. However, in this system, it is normalized to the range of [0, 1]. A larger value indicates that the directions of the two vectors are closer, meaning the task requirement and the node resource state are more matched. For example, if the task resource requirement vector is [20, 32, 50, 1.2, 600] and the node load status vector is [18, 28, 45, 0.9, 480], the cosine similarity between them might be 0.93, indicating a high degree of directional matching in resource requirements and availability, thus yielding a basic matching coefficient of 0.93. Next, the system further calculates the absolute value of the difference between the corresponding dimensions in the same-dimensional feature vector group to obtain a set of dimensional difference values. For example, the difference between the task resource requirement vector and the node dimension vector in terms of GPU computing power is |20-18|=2, in terms of memory capacity it is |32-28|=4, in terms of CPU utilization it is |50-45|=5, in terms of network bandwidth it is |1.2-0.9|=0.3, and in terms of I / O throughput it is |600-480|=120, thus obtaining the set of dimension difference values ​​as [2, 4, 5, 0.3, 120].To facilitate subsequent comparison and fusion, the system normalizes the dimensional difference value set, unifying it to the range [0,1] to form a normalized difference value set. For example, assuming the maximum difference for the GPU dimension is 10 and the current difference is 2, the normalized value is 0.2; the maximum difference for the memory dimension is 50 and the current difference is 4, the normalized value is 0.08, and so on, ultimately resulting in a normalized difference value set such as [0.2, 0.08, 0.1, 0.3, 0.24]. Subsequently, the system weights and sums the normalized difference value set with preset dimensional weights to obtain a comprehensive difference coefficient. For example, if the system's preset dimension weights are [0.4, 0.3, 0.1, 0.1, 0.1], corresponding to the five dimensions of GPU, memory, CPU, network, and I / O respectively, then the weighted comprehensive difference coefficient is: 0.2×0.4 + 0.08×0.3 + 0.1×0.1 + 0.3×0.1 + 0.24×0.1 = 0.08 + 0.024 + 0.01 + 0.03 + 0.024 = 0.168. This coefficient reflects the overall difference between task resource requirements and node resource status across various dimensions; a larger value indicates a greater difference and a lower matching degree. Finally, the system performs numerical fusion based on the basic matching coefficient and the comprehensive difference coefficient to generate a resource affinity matching value. This fusion process typically employs a weighted average or other non-linear combination method, ensuring that the final resource affinity matching value falls within the [0,1] interval, where a larger value indicates a higher 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 × (1 - Comprehensive Difference Coefficient), then the calculation result is 0.93 × (1 - 0.168) = 0.93 × 0.832 ≈ 0.774. This value is the resource affinity matching value between the task and the node, used for subsequent node priority ranking and scheduling decisions. To further illustrate the practical application effect of this mechanism, suppose in a deep learning training platform, a user submits an image classification training task with a task resource requirement vector of [25, 40, 60, 1.5, 700], representing the requirements for GPU computing power, memory, CPU, network bandwidth, and I / O throughput, respectively. After obtaining the node load status data from node A, the system extracts the node dimension vector as [22, 35, 55, 1.2, 600] and performs dimension alignment processing.The basic matching coefficient was calculated to be 0.91, and the dimensional difference value set was [3, 5, 5, 0.3, 100]. After normalization, the difference value set was [0.3, 0.125, 0.083, 0.2, 0.143]. Combined with the preset weights [0.4, 0.3, 0.1, 0.1, 0.1], the comprehensive difference coefficient was calculated to be 0.235. The final resource affinity matching value was 0.91 × (1 - 0.235) ≈ 0.696. Meanwhile, the system performed the same processing on node B and found that its resource affinity matching value was 0.785. Therefore, node B will be given priority for scheduling this task.

[0070] In a specific embodiment, the step of performing node dependency analysis based on the resource affinity matching value to obtain the resource dependency coefficient includes:

[0071] 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.

[0072] 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.

[0073] 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.

[0074] 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.

[0075] Specifically, after calculating the resource affinity matching values, the system uses these values ​​as initial inputs to mine the relationships between computing nodes and construct a node association graph. Each node in this graph represents a computing unit, and the edges in the graph represent resource or task collaboration relationships between nodes. For example, in a data center with 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 between node 3 and node 5, indicating that there are resource dependencies between them. Subsequently, the system assigns weights to these edges, which can be set based on information such as inter-node communication latency, data transmission volume, and historical task scheduling records. For example, if the communication latency between node 1 and node 2 is 0.5ms, the data transmission volume is 1.2GB, and the historical collaborative scheduling success rate is 90%, then considering these factors, the edge weight can be assigned a value of 0.85, thus forming a weighted node association graph. Based on this, the system performs path traversal based on this weighted node association graph to extract the shortest dependency path between any two nodes. The shortest dependency path is the path with the minimum sum of edge weights from one node to another, typically calculated using Dijkstra's algorithm or the Floyd-Warshall algorithm. For example, there might be multiple paths between nodes 1 and 6: path A passes through nodes 2 and 4 with edge weights of 0.8 and 0.7 respectively, and path B passes through nodes 3 and 5 with edge weights of 0.6 and 0.9 respectively. The system accumulates the weights of the two paths, resulting in a path dependency weight of 0.8 + 0.7 = 1.5 for path A and 0.6 + 0.9 = 1.5 for path B. If these weights are equal, the system may select one of them as the shortest dependency path. In this way, the system can identify the optimal resource collaboration path between any two nodes and record its path dependency weight. Subsequently, the system normalizes the path dependency weights between all node pairs, ensuring they all fall within the [0,1] interval, forming standardized path weights. For example, assuming the minimum path dependency weight value is 1.0 and the maximum is 5.0, and a path dependency weight value is 2.5, then its normalized path weight value is (2.5 - 1.0) / (5.0 - 1.0) = 0.375. The normalized weight values ​​facilitate subsequent comparisons and calculations, providing a unified standard for measuring the dependencies between different node pairs. Next, the system arranges these normalized path weights in a matrix according to node pairs, constructing a dependency weight matrix. For example, in a system consisting of 5 computing nodes, the dependency weight matrix will be a 5×5 matrix, where the value in the i-th row and j-th column represents the resource dependency of node i on 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 ​​formed, which is used for subsequent resource dependency coefficient calculation. Finally, the system calculates the resource dependency coefficient of each node by performing a row-by-row weighted average based on this dependency weight matrix and the resource affinity matching value. Specifically, for each row in the dependency weight matrix, the system uses its corresponding resource affinity matching value as a weight, and performs a weighted average with the dependency weight values ​​in that row to calculate the overall impact value of that node in terms of resource dependency. For example, if node 1 has a resource affinity matching value of 0.78, and its corresponding row vector in the dependency weight matrix is ​​[0, 0.375, 0.25, 0.4, 0.15], then the weighted average result is: 0×0.78 + 0.375×0.78 + 0.25×0.78 + 0.4×0.78 + 0.15×0.78 = 0.78 × (0.375 + 0.25 + 0.4 + 0.15) = 0.78 × 1.175 ≈ 0.9165. This value is the resource dependency coefficient of node 1, representing its importance in the resource cooperation network. The higher the resource dependency coefficient, the stronger the resource cooperation relationship between this node and other nodes, and the better its cooperation with other nodes should be considered during scheduling. To further illustrate the practical application effect of this mechanism, suppose a user submits an image classification training task in a deep learning training platform. The system has calculated the resource affinity matching value of each node and constructed a dependency weight matrix. For example, the resource affinity matching value of node A is 0.82, and its corresponding row vector in the dependency weight matrix is ​​[0, 0.4, 0.3, 0.25, 0.15]. Then its resource dependency coefficient is 0.82 × (0.4 + 0.3 + 0.25 + 0.15) = 0.82 × 1.1 ≈ 0.902. Meanwhile, node B has a resource affinity matching value of 0.75 and a dependency weight vector of [0.35, 0, 0.2, 0.15, 0.1]. Therefore, its resource dependency coefficient is 0.75 × (0.35 + 0.2 + 0.15 + 0.1) = 0.75 × 0.8 ≈ 0.6. The system weights and fuses these resource dependency coefficients with the resource affinity matching value to generate a comprehensive affinity value, which is used for subsequent node priority ranking and computing power mapping scheduling.

[0076] In a specific embodiment, the step of performing path traversal based on the weighted node association graph to extract the shortest dependency path between each computing node includes:

[0077] For each computation node in the weighted node association graph, initialize the path record to obtain an initial path record table;

[0078] 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.

[0079] 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.

[0080] Specifically, after constructing the weighted node association graph, each computing node in the system is considered a vertex in the graph. Resource collaboration relationships between nodes are connected by edges, each edge having a weight value representing the degree of resource dependence between two nodes. For example, in a data center containing 5 computing nodes (A, B, C, D, E), there might be an edge between nodes A and B with a weight of 0.6, indicating a certain resource collaboration requirement between them; the edge between nodes B and C has a weight of 0.4, indicating stronger collaboration, and so on. To extract the shortest dependency path between any two nodes, the system first initializes the path record for each node. Taking node A as an example, the system sets the path length from A to itself to 0 and initializes the path node sequence to [A], indicating that the path from A to A only includes A itself; for the path length from A to other nodes (such as B, C, D, E), the system initially sets it to infinity (∞), indicating that no effective path has been found. This initialization process provides a starting point for subsequent path updates and optimizations. Subsequently, based on the initial path record table, the system selects intermediate nodes sequentially in descending order of node degree to serve as bridges for path updates. Node degree refers to the number of connections between a node and other nodes; a higher degree indicates a more critical node in the resource collaboration network. For example, in the 5-node system mentioned above, nodes B and C have degrees of 3 and 3 respectively, higher than other nodes. Therefore, the system prioritizes selecting B and C as intermediate nodes for path updates. Taking node B as an example, the system checks whether it is possible to reach other nodes from the starting node A via node B and calculates the corresponding path length. For instance, if the current path length from A to B is 0.6, and the edge weight from B to C is 0.4, then the path length from A to C via B is 0.6 + 0.4 = 1.0. Since this value is less than the initially set 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 via B is 0.6 + 0.9 = 1.5, and the system records this as the current optimal path from A to D. After updating the path for intermediate node B, the system selects the next intermediate node C and performs a similar operation. For example, if the edge weight from C to E is 0.7, then the path length from A to E via C is 1.0 (the 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 is [A, B, C, E]. Furthermore, the system checks other possible paths. For example, the path length from A to E via D is 1.5 (A to D) + 0.5 (D to E) = 2.0. Since this value is greater than 1.7, it is not updated. The system repeats the above process sequentially for all nodes as starting nodes, ensuring that the paths between each pair of nodes are fully updated.Finally, the system selects the shortest path length from all path records and extracts its corresponding path node sequence to form a set of shortest dependency paths between computing nodes. For example, in the example above, the shortest dependency path from node A to E is [A, B, C, E], with a path length of 1.7; 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 relationships between nodes but also provide an important basis for subsequent calculation of resource dependency coefficients. For example, when constructing the dependency weight matrix later, these path lengths will be normalized and converted into standardized path weights to measure the dependency strength between different nodes. In this way, the system can more accurately evaluate the collaborative impact between nodes during task scheduling, thereby improving the intelligence level of resource scheduling and task execution efficiency. To further illustrate the practical application effect of this mechanism, suppose that in a deep learning training platform, a user submits an image classification training task, the system has constructed a weighted node association graph, and extracted the shortest dependency path through the above path traversal mechanism. For example, if 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, then the shortest path length from node A to E is 1.7. These path lengths will be used for subsequent normalization processing 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 achieves accurate modeling of resource collaboration paths between computing nodes, providing crucial path dependency information for resource scheduling. This mechanism not only improves the intelligence 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 update, and minimum value selection can effectively identify the optimal resource collaboration path between nodes, possessing significant technical advantages and engineering application value.

[0081] In a specific embodiment, 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:

[0082] 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.

[0083] The resource satisfaction level is obtained by calculating the ratio between the candidate nodes and the task resource requirement vector.

[0084] 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.

[0085] 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.

[0086] Specifically, after generating the node priority sequence, the system sorts the node load status data of each computing node according to this priority order, forming a sorted load status vector. For example, in a system consisting of 5 computing nodes, assuming the node priorities of nodes A, B, C, D, and E are 1, 3, 2, 5, and 4 respectively, the sorted node order will be A, C, B, E, and D, with corresponding load status vectors of [A: GPU 18 TFLOPS, Memory 28GB, CPU 45%], [C: GPU 20 TFLOPS, Memory 30GB, CPU 50%], [B: GPU 19 TFLOPS, Memory 25GB, CPU 60%], [E: GPU 15 TFLOPS, Memory 20GB, CPU 70%], and [D: GPU 10 TFLOPS, Memory 15GB, CPU 85%]. Subsequently, the system calculates the difference between the sorted load status vector and the task resource requirement vector to obtain the node resource gap value for each node. For example, assuming the task resource requirement vector is [GPU 20 TFLOPS, Memory 32GB, CPU 60%], then for node A, its GPU resource gap is 20 - 18 = 2 TFLOPS, its memory gap is 32 - 28 = 4GB, and its CPU gap is 60% - 45% = 15%. The system judges these resource gap values ​​as positive or negative, retaining only nodes with all non-positive resource gap values ​​as candidate nodes. For example, node C has GPU resources of 20 TFLOPS (just meeting the requirement), memory of 30 GB (slightly below the requirement), and CPU of 50% (below the task requirement). Therefore, its GPU resource gap is 0, its memory gap is 2GB (negative), and its CPU gap is 10% (positive). Thus, this node will be selected as a candidate node because its overall resource gap values ​​meet or are close to the task requirement. Next, the system calculates the resource satisfaction level based on the load status of the candidate nodes and the task resource requirement vector. Resource satisfaction is a quantitative evaluation metric for whether the resources of a candidate node meet the task requirements. It is usually expressed as a weighted average of resource dimension matching scores. For example, node C has a GPU dimension satisfaction score of 1.0 (just meets the requirements), a memory dimension satisfaction score of 0.94 (30 / 32), and a CPU dimension satisfaction score of 0.83 (50 / 60). If the weights of each dimension are 0.5, 0.3, and 0.2 respectively, then its resource satisfaction score is 0.5×1.0 + 0.3×0.94 + 0.2×0.83 ≈ 0.94, which is higher than the preset threshold of 0.85. Therefore, this node is confirmed as a valid candidate node. After confirming the candidate nodes, the system further performs task sharding adaptation analysis to determine whether the task can be reasonably divided into multiple subtasks and mapped to different candidate nodes.For example, a deep learning training task can be broken down into multiple model training subtasks, each with different requirements for GPU resources, memory, and CPU. The system generates a sharding adaptation scheme based on the granularity of task sharding, the availability of node resources, and the communication overhead between nodes. It then binds each shard task to a corresponding candidate node, forming a preliminary scheduling mapping table. For instance, a task might be split into three subtasks T1, T2, and T3, where T1 maps to node C, T2 to node B, and T3 to node A. Finally, the system calculates the load balancing coefficient of the nodes in the preliminary scheduling mapping table to assess whether resource overload or uneven load will occur after each node executes the task. The load balancing coefficient is an important indicator of the uniformity of the overall system load distribution, typically calculated based on the variance or standard deviation of node load changes. For example, if node A's load increases from 45% to 65% after executing the task, node B's from 60% to 75%, and node C's from 50% to 60%, the system calculates a load balancing coefficient of 0.12 (a smaller value indicates a more balanced load). If the coefficient is higher than a preset threshold (e.g., 0.15), the system adjusts and optimizes the initial scheduling mapping table. For example, it migrates some subtasks from node B to node E to alleviate the high load pressure on node B, thus forming the final computing power scheduling scheme. To further illustrate the practical application effect of this mechanism, suppose 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 rates to be 0.92, 0.95, and 0.88, respectively, all higher than the threshold of 0.85. The system then split the task into three subtasks, mapping them to the three nodes respectively. Load balancing analysis revealed that node B's load rose to 80% after task execution, slightly higher than other nodes. Therefore, the system migrated one of the subtasks from node B to node E, adjusting the load of each node to A: 65%, C: 60%, B: 68%, and E: 55%, respectively. The final load balancing coefficient was reduced to 0.09, resulting in a more balanced overall system load distribution. Through this scheduling mapping and optimization mechanism, the system achieved efficient matching between task resource requirements and node resource status, improving not only task execution efficiency but also enhancing the system's control over resource load distribution. This scheduling strategy, based on node priority, resource gap assessment, resource satisfaction evaluation, task sharding adaptation, and load balancing optimization, effectively supports task scheduling needs in complex computing environments, demonstrating significant technological innovation and engineering application value.

[0087] The resource affinity-based computing power scheduling method in the embodiments of the present invention has been described above. The resource affinity-based computing power scheduling device in the embodiments of the present invention is described below. Please refer to [link / reference]. Figure 2 One embodiment of the resource affinity-based computing power scheduling device in this invention includes:

[0088] The acquisition module 21 is used to collect the load status of each computing node in the target device through the computing node monitoring module to obtain node load status data.

[0089] The parsing module 22 is used to parse 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.

[0090] Analysis module 23 is used to perform node dependency analysis based on the resource affinity matching value, obtain resource dependency coefficient, and perform weighted calculation on the resource affinity matching value and the resource dependency coefficient to obtain a comprehensive affinity value;

[0091] The sorting module 24 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 demand vector based on the node priority sequence to obtain a computing power scheduling scheme.

[0092] In this embodiment, the specific implementation of each unit in the above device embodiment is described in the above method embodiment, and will not be repeated here.

[0093] Reference Figure 3 This invention also provides a computer device whose internal structure can be as follows: Figure 3 As shown, the computer device includes a processor, memory, display screen, input device, network interface, and database connected via a system bus. The processor provides computing and control capabilities. The memory includes a non-volatile storage medium and internal memory. The non-volatile storage medium stores the operating system, computer programs, and database. The internal memory provides an environment for the operation of the operating system and computer programs in the non-volatile storage medium. The database stores the data corresponding to this embodiment. The network interface is used to communicate with external terminals via a network connection. When the computer program is executed by the processor, it implements the above-described method.

[0094] Those skilled in the art will understand that Figure 3 The structures shown are merely block diagrams of some structures related to the present invention and do not constitute a limitation on the computer devices on which the present invention is applied.

[0095] An embodiment of the present invention also provides a computer-readable storage medium having a computer program stored thereon, which, when executed by a processor, implements the above-described method. It is understood that the computer-readable storage medium in this embodiment can be a volatile readable storage medium or a non-volatile readable storage medium.

[0096] Those skilled in the art will understand that all or part of the processes in the methods of the above embodiments can be implemented by instructing related nodes through a computer program. The computer program can be stored in a non-volatile computer-readable storage medium. When executed, the computer program can include the processes of the embodiments of the above methods. Any references to memory, storage, databases, or other media used in the present invention and embodiments can include non-volatile and / or volatile memory. Non-volatile memory can include read-only memory (ROM), programmable ROM (PROM), electrically programmable ROM (EPROM), electrically erasable programmable ROM (EEPROM), or flash memory. Volatile memory can include random access memory (RAM) or external cache memory. By way of illustration and not limitation, RAM is available in various forms, such as static RAM (SRAM), dynamic RAM (DRAM), synchronous DRAM (SDRAM), dual-rate SDRAM (SSRSDRAM), enhanced SDRAM (ESDRAM), synchronous link DRAM (SLDRAM), Rambus direct RAM (RDRAM), direct memory bus dynamic RAM (DRDRAM), and memory bus dynamic RAM, etc.

[0097] It should be noted that, in this document, the terms "comprising," "including," or any other variations thereof are intended to cover non-exclusive inclusion, such that a process, apparatus, article, or method that comprises a list of elements includes not only those elements but also other elements not expressly listed, or elements inherent to such process, apparatus, article, or method. Unless otherwise specified, an element defined by the phrase "comprising one..." does not exclude the presence of other identical elements in the process, apparatus, article, or method that includes that element.

[0098] The above description is only a preferred embodiment of the present invention and does not limit the patent scope of the present invention. Any equivalent structural or procedural transformations made based on the content of the present invention specification and drawings, or direct or indirect applications in other related technical fields, are similarly included within the patent protection scope of the present invention.

Claims

1. A resource affinity-based computing power scheduling method, characterized in that, The method comprises the following steps: Collecting load states of each computing node in the target device through the computing node monitoring module to obtain node load state data; Analyzing 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; Performing descending order sorting on the comprehensive affinity value 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; The affinity matching of the task resource demand vector based on the node load state data to obtain a resource affinity matching value comprises: Extracting the dimensions of the node load state data to obtain a node dimension vector, and performing dimension alignment processing on the dimensions of the task resource demand vector and the node dimension vector to obtain a same dimension feature vector group; Performing vectorization processing on the node load state data to obtain a node load state vector, calculating the cosine similarity between the task resource demand vector and the node load state vector based on the same dimension feature vector group to obtain a basic matching coefficient, and performing absolute value difference calculation on the numerical values of the corresponding dimensions in the same dimension feature vector group to obtain a dimension difference value set; Performing normalization conversion on the dimension difference value set to obtain a normalized difference value set, and performing weighted summation on the normalized difference value set and a preset dimension weight to obtain a comprehensive difference coefficient; Numerical fusion based on the basic matching coefficient and the comprehensive difference coefficient to obtain a resource affinity matching value The computing power mapping scheduling of the task resource demand vector based on the node priority sequence to obtain a computing power scheduling scheme comprises: Sorting the node load state data according to the node priority sequence to obtain a sorted load state vector, performing difference calculation on the sorted load state vector and the task resource demand vector to obtain a node resource gap value, and performing positive and negative judgment on the node resource gap value to select candidate nodes with non-positive resource gap values; Performing proportional calculation on the candidate nodes and the task resource demand vector to obtain a resource satisfaction degree; Performing task fragmentation adaptation analysis on the candidate nodes whose resource satisfaction degrees reach a preset threshold to obtain a fragmentation adaptation scheme, and performing binding mapping on the fragmented tasks in the fragmentation adaptation scheme and the candidate nodes to obtain a preliminary scheduling mapping table; Calculating the node load balancing degree in the preliminary scheduling mapping table to obtain a load balancing coefficient, and adjusting and optimizing the preliminary scheduling mapping table based on the load balancing coefficient to obtain a computing power scheduling scheme.

2. The resource affinity-based computing power scheduling method according to claim 1, characterized in that, The node load state data obtained by collecting the load states of each computing node in the target device through the computing 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.

3. The resource affinity-based computing power scheduling method according to claim 1, wherein, The demand analysis of the computing task submitted by the target user obtains a task resource demand vector, including: The syntax structure of the description text in the computing task submitted by the target user is analyzed to extract a task attribute feature set, and the computing task is classified and coded based on the task attribute feature set to obtain a task classification coding vector; The task classification coding vector is matched and searched in a preset resource mapping rule library to obtain a task resource demand vector.

4. The resource affinity-based computing power scheduling method according to claim 1, characterized in that, The resource affinity matching value is used to analyze the node dependency relationship to obtain a resource dependency coefficient, including: The computing nodes corresponding to the resource affinity matching value are associated to mine the node association graph, and the edges in the node association graph are weighted to obtain a weighted node association graph; The weighted node association graph is traversed to extract the shortest dependency path between each computing node, and the weight of the shortest dependency path is 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; The dependency weight matrix and the resource affinity matching value are used for row-by-row weighted average calculation to obtain the resource dependency coefficient of each computing node.

5. The resource affinity-based computing power scheduling method according to claim 4, characterized in that, The weighted node association graph is traversed to extract the shortest dependency path between each computing node, including: Each computing node in the weighted node association graph is initialized for path recording to obtain an initial path recording table; In the initial path recording table, the intermediate nodes are selected in order of node degree from high to low, the path length from the starting node to other nodes through the intermediate nodes is compared and updated, and an updated path recording table is obtained; The path length in the updated path recording table is filtered for 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 path between each computing node.

6. The resource affinity-based computing power scheduling apparatus, characterized in that, including: The acquisition module is configured to collect node load state data by the computing node monitoring module in the target device; The analysis module is configured to analyze the demand of the computing task submitted by the target user to obtain a task resource demand vector, and perform affinity matching on the task resource demand vector based on the node load state data to obtain a resource affinity matching value; The analysis module is configured to perform node dependency 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 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. The affinity matching of the task resource demand vector based on the node load state data includes: 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 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 difference of the corresponding dimension values 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 is weighted and summed with a preset dimension 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. The computing power scheduling scheme is obtained by performing computing power mapping scheduling on the task resource demand vector based on the node priority sequence, including: The node load state data is sorted according to the node priority sequence to obtain a sorted load state vector, 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 positively and negatively judged to filter out candidate nodes with non-positive resource gap values. The resource satisfaction degree is obtained by performing proportional calculation on the candidate nodes and the task resource demand vector. Task fragmentation adaptation analysis is performed on the candidate nodes whose resource satisfaction degree reaches 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 coefficient is obtained by calculating the node load balancing degree in the preliminary scheduling mapping table, and the preliminary scheduling mapping table is adjusted and optimized based on the load balancing coefficient to obtain the computing power scheduling scheme.

7. A computer device comprising a memory and a processor, the memory having stored therein a computer program, characterized in that, The processor executes the computer program to implement the steps of the method of any one of claims 1 to 5.

8. A computer readable storage medium having stored thereon a computer program, characterized in that, The computer program is executed by the processor to implement the steps of the method of any one of claims 1 to 5.

Images