Heterogeneous cloud container cluster scheduling model training method and scheduling method based on topology awareness

Abstract

The invention belongs to the technical field of intelligent scheduling, and particularly relates to a heterogeneous cloud container cluster scheduling model training method and scheduling method based on topology awareness, and the training method comprises the steps: obtaining a cluster topological graph; obtaining a state vector time sequence of the nodes based on the node operation data, wherein each state vector comprises a performance index representing bottom layer resource contention; obtaining a queue state matrix; processing the state vector time sequence by using a feature extractor to obtain a node initial embedding vector; processing the initial embedded vectors of all the nodes by using a graph attention network to obtain a cluster global topology vector; obtaining a joint observation state based on the cluster global topology vector and the queue state matrix; inputting the joint observation state to the Actor-Critic network to generate a scheduling strategy; the accumulated rewards are maximized through a near-end strategy optimization algorithm, and network parameters are updated; and connecting the feature extractor, the graph attention network and the decision network to form a scheduling model. And the topological relation between the nodes is globally sensed, the interference attribute of the micro-architecture is captured, and accurate scheduling is realized.

Description

Technical Field

[0001] This invention relates to the field of intelligent scheduling technology, and in particular to a training method and scheduling method for a topology-aware heterogeneous cloud container cluster scheduling model. Background Technology

[0002] With the rapid development of cloud computing technology and the widespread adoption of microservice architecture, cloud container orchestration technology is increasingly used in modern data centers, providing crucial support for enterprise digital transformation and large-scale computing services. In cloud-native production scenarios, efficient resource scheduling systems typically rely on rapid and accurate perception of heterogeneous cluster states and mixed load characteristics. However, due to the complexity of data center hardware environments (such as multi-core processors and multi-level cache architectures), the collected node (physical server) status data suffers from microscopic invisibility, topological dependencies, and dynamic time-varying characteristics, making it difficult to obtain a sufficiently detailed and global resource view, thus affecting the accuracy and globality of scheduling.

[0003] In practical applications, heterogeneous cloud container clusters exhibit a large number of differentiated hardware configurations, different types of interference-sensitive services, and batch processing tasks with diverse resource consumption characteristics. The granularity and globality of the scheduling strategy directly determine the overall performance and service stability of the cloud container cluster. If the cloud container cluster scheduling method lacks the ability to perceive the physical topology of the cloud container cluster and cannot capture the resource contention state at the micro-architecture level, it will be unable to fully perceive the potential micro-architecture contention and topological constraints in physical nodes (physical servers), thus triggering a severe "noisy neighbor" effect—that is, even when explicit resources such as CPU cores are sufficient, underlying implicit resources such as cache, memory bandwidth, and bus conflict, causing drastic fluctuations in the response latency of critical services. This is also a core problem that urgently needs to be solved in the scheduling of heterogeneous cloud container clusters. Among them, interference perception at the micro-architecture level and topology-coordinated scheduling are the key pain points in this problem.

[0004] Relevant cloud container cluster scheduling methods mainly include traditional rule-based heuristic algorithms and optimization scheduling methods based on basic reinforcement learning. Traditional rule-based heuristic scheduling methods cannot actively learn complex micro-architectural interference patterns; they can only allocate and manage explicit resources such as CPU and memory of nodes (physical servers), and cannot actively learn complex micro-architectural interference patterns in heterogeneous cloud container clusters. While optimization scheduling methods based on basic reinforcement learning possess a certain degree of autonomous learning and adaptive capabilities, they mostly focus only on the scalar resource characteristics of a single node (physical server), lacking the ability to extract and perceive the overall graph structure characteristics of the cluster. They cannot capture the physical topological dependencies and implicit interference relationships between nodes, leading to scheduling decisions easily getting trapped in local optima when facing high-concurrency, strongly coupled business scenarios.

[0005] In summary, the existing cloud container cluster scheduling methods cannot effectively perceive the microarchitectural interference of physical nodes and the complex topological constraints of the cluster, which affects the globality and anti-interference capability of scheduling decisions. Summary of the Invention

[0006] This application aims to at least solve the technical problems existing in the prior art and provide a training method and scheduling method for a topology-aware heterogeneous cloud container cluster scheduling model.

[0007] Firstly, this application provides a training method for a topology-aware heterogeneous cloud container cluster scheduling model. The method includes: using physical servers of the heterogeneous cloud container cluster as nodes, constructing edges based on the connection relationships between nodes to obtain a cluster topology graph; collecting node runtime data, and obtaining a state vector time series of nodes at time t based on the node runtime data, wherein each state vector in the state vector time series includes a performance indicator representing underlying resource contention; obtaining the queue state matrix at time t based on the task buffer queue to be scheduled at time t; iteratively executing the following steps until the training completion condition is met: using a feature extractor to process the state vector time series of nodes at time t to obtain the initial embedding vector of nodes at time t; and utilizing... The initial embedding vectors of all nodes at time t are processed using a graph attention network to obtain the cluster global topology vector at time t. Based on the cluster global topology vector and the queue state matrix at time t, the joint observation state at time t is obtained. The joint observation state at time t is input into the Actor-Critic network to generate a scheduling policy. After executing the scheduling action based on the scheduling policy, the reward value is calculated. The cumulative reward is maximized using the near-end policy optimization algorithm based on the reward value, and the parameters of the feature extractor, graph attention network, and Actor-Critic network are updated. Let t = t + 1. After training, the decision network that connects the feature extractor, graph attention network, and Actor-Critic network in sequence constitutes the scheduling model.

[0008] The above technical solution generates a cluster topology graph by using physical servers as nodes and constructing edges based on node connection relationships. It can perceive the actual physical topology connection relationships and interference affinity connections between nodes, avoid the one-sidedness of scheduling decisions caused by ignoring topology constraints, and realize global resource status cognition. Introducing performance metrics representing underlying resource contention into each state vector of the state vector time series at node t allows the model training process to capture not only explicit resources such as the number of CPU cores, but also microarchitectural interference attributes, namely the contention state of underlying implicit resources such as cache, memory bandwidth, and bus. This solves the problem that traditional methods only focus on explicit resources and cannot identify microarchitectural interference, thus avoiding conflicts in underlying implicit resources that could lead to severe fluctuations in response latency for critical business operations. The initial embedding vector is obtained by processing the node state vector time series by the feature extractor. Then, the initial embedding vectors of all nodes are aggregated by the graph attention network to generate the global topology vector of the cluster. This allows the model to extract the graph structure features of the entire cluster, rather than just focusing on the resource state of a single node. This solves the problem that basic reinforcement learning scheduling methods are prone to getting trapped in local optima and improves the globality of scheduling decisions. The parameters of the feature extractor, graph attention network, and Actor-Critic network are updated synchronously through reinforcement learning algorithms. The training process iteratively combines the joint observation state generated by the cluster global topology vector and the queue state matrix, enabling the model to learn the dynamic matching rules of cluster resource state and the needs of scheduled tasks at the same time. This solves the problem of poor scheduling adaptability caused by the time-varying state of heterogeneous clusters and the diversity of task loads. The trained scheduling model can accurately match the complex scheduling needs of heterogeneous cloud container clusters.

[0009] Secondly, this application provides a scheduling method for heterogeneous cloud container clusters. The method includes: collecting node runtime data and obtaining a state vector time series of the node at the current moment based on the node runtime data; obtaining a queue state matrix at the current moment based on the task buffer queue to be scheduled at the current moment; inputting the state vector time series and queue state matrix of all nodes in the cluster topology graph at the current moment into a scheduling model, wherein the decision network of the Actor-Critic network in the scheduling model generates scheduling actions and executes the scheduling actions; wherein the scheduling model is obtained according to the topology-aware heterogeneous cloud container cluster scheduling model training method described in the first aspect of this application.

[0010] In addition to the beneficial effects of the first aspect, the above technical solution can significantly improve the resource scheduling efficiency of heterogeneous cloud container clusters under complex mixed loads, effectively avoid the "noisy neighbor" effect at the microarchitecture level, and improve the service level target (SLO) achievement rate.

[0011] Thirdly, this application provides a computer device including a memory, a processor, and a computer program stored in the memory, wherein the processor executes the computer program to implement the steps of the method described in the first or second aspect of this application. Attached Figure Description

[0012] Figure 1 This is a flowchart illustrating a preferred embodiment of the training method for a topology-aware heterogeneous cloud container cluster scheduling model according to the present invention. Figure 2 This is a schematic diagram of the heterogeneous cloud container cluster scheduling process in an example of the present invention; Figure 3 This is a schematic diagram of the initial embedding vector acquisition process of a node in a preferred embodiment of the present invention; Figure 4 This is a schematic diagram of the cluster topology in one example of the present invention; Figure 5 This is a schematic diagram of the attention network processing procedure in a preferred embodiment of the present invention; Figure 6 This is a schematic diagram of the queue state matrix generation process in a preferred embodiment of the present invention; Figure 7 This is a flowchart illustrating a preferred embodiment of the scheduling method for a heterogeneous cloud container cluster according to the present invention. Figure 8 This is a schematic diagram of the scheduling model processing in a preferred embodiment of the present invention; Figure 9 This is a schematic diagram of the structure of an electronic device in a preferred embodiment of the present invention. Detailed Implementation

[0013] The specific embodiments of the present invention will be described in detail with reference to the accompanying drawings. It should be noted that the technical terms in the following embodiments are defined as follows: Node refers to a physical server in a heterogeneous cloud container cluster; Cluster topology graph refers to a directed attribute graph composed of physical servers as vertices and connection relationships as edges; State vector refers to a multi-dimensional vector characterizing the resource state and load characteristics of a node at a certain moment; Microarchitectural interference attribute refers to a performance indicator characterizing the contention for underlying hardware resources; Feature extractor refers to a neural network module used to process time-series data and extract time-series features; Graph attention network refers to a neural network used to process graph-structured data and calculate the relationships between nodes to obtain the global topology vector of the cluster; Actor-Critic network refers to a reinforcement learning architecture that includes a policy network (Actor) and a value network (Critic); Proximal policy optimization algorithm (PPO) refers to a reinforcement learning algorithm based on policy gradients.

[0014] This invention discloses a training method for a topology-aware heterogeneous cloud container cluster scheduling model and a scheduling method for heterogeneous cloud container clusters. The execution entities of these methods include, but are not limited to, at least one of the following electronic devices that can be configured to execute the method provided in this application: a server, a terminal, or a computer. In other words, the methods can be executed by software or hardware installed on a terminal device or a server device, where the software may be a blockchain platform. The server includes, but is not limited to, a single server, a server cluster, a cloud server, or a cloud server cluster. The server can be an independent server or a cloud server providing basic cloud computing services such as cloud services, cloud databases, cloud computing, cloud functions, cloud storage, network services, cloud communication, middleware services, domain name services, security services, content delivery networks (CDNs), and big data and artificial intelligence platforms.

[0015] This invention discloses a training method for a topology-aware heterogeneous cloud container cluster scheduling model. In a preferred embodiment, please see... Figure 1 The method includes: Step S10: Using the physical servers of the heterogeneous cloud container cluster as nodes, construct edges based on the connection relationships between nodes to obtain the cluster topology graph.

[0016] like Figure 4 As shown, the cluster topology diagram From node set (Vertex set) and edge set Composition, node set Corresponding physical server set, edge set From the adjacency matrix Definition, Adjacency Matrix The dimension is ,in, This represents the total number of physical servers contained in a heterogeneous cloud container cluster. , All are node indexes; traversing all node pairs When node With nodes When the connection relationship between them satisfies the connection condition, set the adjacency matrix elements. ,otherwise .

[0017] Preferably, the connection conditions include at least one of two types. The first type is that there is a physical topological connection between the two nodes, that is, the nodes... With nodes Located in the same rack or connected to the same top rack switch, the two nodes share power infrastructure or uplink bandwidth, resulting in a physical resource coupling relationship. The second type is interference affinity connection, which is based on historical monitoring data analysis and involves nodes... With nodes The cache miss rate showed a significant positive correlation, and the Pearson correlation coefficient Greater than the preset correlation coefficient threshold This indicates that there is a potential storage input / output bottleneck coupling or business dependency between the two nodes.

[0018] Physical topology connectivity is determined based on the data center's network topology configuration information, obtained by querying the network management system to obtain node rack locations and switch connection information. Interference affinity connectivity is determined based on node performance monitoring data. The system continuously collects the final-level cache miss rate of nodes and calculates the Pearson correlation coefficient between the cache miss rate sequences of any two nodes within a time window. When the correlation coefficient exceeds a threshold... Establish connections at specific times, with a correlation coefficient threshold. The typical value range is 0.6 to 0.8, with 0.7 being preferred. Correlation coefficient threshold. The settings can be based on statistical criteria for determining significant correlation. Through the construction of these two types of connections, the cluster topology graph explicitly encodes physical constraints and implicit interference relationships, providing structured input for subsequent topology-aware processing. By constructing edge sets in this way, the cluster topology graph explicitly encodes physical constraints and implicit interference relationships in heterogeneous cloud container clusters.

[0019] Step S11: Collect the node's operational data and obtain the state vector time series of the node at time t based on the node's operational data. Each state vector in the state vector time series includes a performance index representing the underlying resource contention.

[0020] like Figure 3 As shown, the system collects data in real time from the cloud data center environment from the cluster. Taiwan physical server (node) The running data at time t is used to construct the state vector at time t. Preferably, each state vector includes at least one of three performance metrics: static capacity attribute, dynamic load attribute, and microarchitectural interference attribute. The microarchitectural interference attribute includes at least one of the following: instruction count per clock cycle, last-level cache miss rate, and memory bandwidth usage. For example, the state vector at time t... Includes: static capacity attribute Dynamic load attributes and microarchitecture interference properties Static capacity attribute Characterizing the node's hardware configuration, including the number of physical CPU cores, total memory capacity, and maximum network interface card (NIC) bandwidth. Typical ranges for the number of physical CPU cores are 8 to 128, total memory capacity is 16GB to 512GB, and maximum NIC bandwidth is 1Gbps to 100Gbps. Dynamic load attributes. This characterizes the real-time resource utilization status of nodes, including CPU utilization, memory utilization, and network utilization. Utilization is expressed as a percentage, ranging from 0% to 100%. Microarchitectural interference attributes. The underlying resource contention status within a node is characterized by indicators including Instructions Per Clock (IPC), Last-Level Cache Miss Rate (LLC Miss Rate), and Memory Bandwidth Usage. IPC reflects the CPU's instruction execution efficiency, typically ranging from 0.5 to 4.0. An IPC below 1.0 indicates pipeline stalls. The LLC Miss Rate reflects cache hit efficiency, expressed as a percentage, typically ranging from 1% to 30%. A miss rate above 10% indicates cache contention. Memory Bandwidth Usage reflects memory bus occupancy, measured in GB / s, typically ranging from 10GB / s to 200GB / s. Usage approaching hardware limits indicates a memory bandwidth bottleneck. Based on these metrics, the node... The state vector at time t is constructed as follows The vector has a dimension of d, typically ranging from 10 to 20 dimensions. By introducing three types of performance metrics, especially microarchitectural interference attributes, the state vector can comprehensively characterize the resource status and performance characteristics of nodes, providing a refined data foundation for topology awareness and interference avoidance.

[0021] The system operates at fixed time intervals. Collect node operation data and generate state vectors at time intervals. Typical values ​​range from 10 to 60 seconds, with 30 seconds being preferred. The acquisition time interval is set based on a balance between the time scale of load changes and the computational cost of data acquisition. For nodes... The system saves the most recent The state vectors at each time step constitute the nodes. State vector time series at time t Time window length The typical value is 10 to 50, preferably 20, and the length is set based on the typical time span of the load periodicity pattern.

[0022] Step S12: Obtain the queue state matrix at time t based on the task buffer queue to be scheduled at time t.

[0023] It should be noted that the execution order of steps S10, S11, and S12 is not limited here.

[0024] In this embodiment, preferably, such as Figure 4 As shown, step S12 includes: Step S121: Obtain the multidimensional feature vector of each task in the task queue to be scheduled at time t; Step S122: Calculate the dynamic score of the task based on the fitness operator, similarity density, and task waiting time for each task; Step S123: Stack the multidimensional feature vectors of the top-K tasks in the dynamic scoring ranking and the dynamic scores to form the queue state matrix at time t. K is a positive integer.

[0025] In this embodiment, newly arrived tasks enter a task queue to be scheduled. The contents of the task queue to be scheduled vary at different times. In step S121, the executing entity extracts tasks from the task queue to be scheduled at time t. Multidimensional feature vectors , Indicates central processing unit requirements. Indicates memory requirements. Indicates the level of interference sensitivity. Central Processing Unit (CPU) requirements. Indicates the number of CPU cores required for the task, typically ranging from 0.1 to 32 cores. Memory requirements. Indicates the memory required for the task, in GB, typically ranging from 0.5GB to 256GB. Interference sensitivity level. The sensitivity of a task to microarchitectural interference is categorized into three levels: high sensitivity, medium sensitivity, and low sensitivity. Online latency-sensitive tasks are typically classified as high sensitivity, while offline batch processing tasks are typically classified as low sensitivity. The levels are encoded numerically: high sensitivity is coded as 3, medium sensitivity as 2, and low sensitivity as 1.

[0026] In this embodiment, in step S122, in order to avoid resource fragmentation and prevent long-tail tasks from starving, a dynamic scoring function is designed to sort tasks in real time, and the dynamic score of the task is calculated based on the fitness operator, similarity density and task waiting time of each task.

[0027] The dynamic scoring function is expressed as: Indicates task Dynamic scoring; the dynamic scoring function comprehensively considers three factors: fitness operator. Similar density and task waiting time .

[0028] Fit Operator The degree of matching between task requirements and the maximum fragmentation of the cluster is measured by traversing all nodes and finding those that can accommodate the task. The node with the smallest remaining resources is used as the fitness value; the smaller the fitness value, the higher the degree of matching.

[0029] Similar density Indicates tasks in the cluster The number of tasks of the same type is used to suppress homogeneous stacking. The criteria for determining the same type are that the resource requirements and sensitivity levels of the tasks are the same or similar.

[0030] Task waiting time Indicates task From arrival time The waiting time up to the current time t, in seconds.

[0031] in , , These are the first weighting coefficient, the second weighting coefficient, and the third weighting coefficient, with typical values ​​of... , , The weighting coefficients are set based on the relative importance of different factors to scheduling priority. The higher the dynamic score, the higher the task priority. The system sorts the tasks in the queue in descending order according to the score results, selecting the top K tasks with the highest dynamic scores. A typical value for K is 10 to 50, with 20 being preferred. The multidimensional feature vectors pi and dynamic scores qi of the selected TOP-K tasks are stacked row-wise to form the queue state matrix Squeue at time t, with dimensions of [missing information]. ,in For multidimensional feature vector dimensions, The 1 in the equation corresponds to dynamic scoring. The queue state matrix Squeue at time t condenses the information of the most urgent or most suitable tasks for scheduling, providing task-side context input for scheduling decisions. Through the dynamic scoring mechanism, the system can achieve a balance between resource utilization efficiency, interference avoidance, and task fairness, avoiding resource fragmentation and long-tail task starvation, and improving the globality and rationality of scheduling decisions.

[0032] Step S13: Iteratively execute the following steps S131-135 until the training completion condition is met.

[0033] In this embodiment, the training completion conditions include two categories: the first category is reaching a preset maximum number of training rounds, typically ranging from 1000 to 5000 rounds, preferably 3000 rounds; the second category is that the cumulative reward growth for multiple consecutive rounds is lower than a preset threshold, typically ranging from 50 to 100 rounds, and the reward growth threshold typically ranging from 0.01 to 0.001. In each training round, the following steps are performed: Step S131: Use the feature extractor to process the state vector time series of node t to obtain the initial embedding vector of node t.

[0034] In this embodiment, the feature extractor is not limited to a long short-term memory network or a one-dimensional convolution, so that the initial embedding vector contains the load evolution pattern and microarchitectural state change trend of the node within the historical time window, providing rich node feature representations for subsequent graph attention network processing, which helps to improve scheduling accuracy.

[0035] Step S132: Use a graph attention network to process the initial embedding vectors of all nodes at time t to obtain the global topology vector of the cluster at time t.

[0036] Step S133: Obtain the joint observation state at time t based on the cluster global topology vector and queue state matrix at time t.

[0037] Specifically, the joint observation state at time t The joint observation state at time t is formed by concatenating the cluster global topology vector and the queue state matrix. The concatenation operation flattens the cluster global topology vector and the queue state matrix into a one-dimensional vector, and then concatenates the two one-dimensional vectors end to end to form the joint observation state at time t. It contains information on both the resources available in the cluster and the tasks available in the queue, providing a comprehensive basis for decision-making in the Actor-Critic network.

[0038] Step S134: Input the joint observation state at time t into the Actor-Critic network to generate the scheduling strategy.

[0039] In this embodiment, the joint observation state at time t is input into the Actor-Critic network to generate a scheduling policy. The scheduling policy is the probability distribution of the allocation nodes for the highest priority task. The probability distribution of the allocation nodes includes the probability of the task being allocated to all physical servers in the cluster and the probability of deferring the scheduling action. Figure 8 As shown, the Actor-Critic network consists of two sub-networks: a policy network (Actor) and a value network (Critic). The policy network (Actor) is responsible for generating the probability distribution of scheduled actions, while the value network (Critic) is responsible for evaluating the value of the current state.

[0040] The policy network (Actor) employs a multilayer perceptron (MLP) architecture, comprising an input layer, hidden layers, and an output layer. The input layer receives the joint observation states. The hidden layer consists of two fully connected layers, each followed by a ReLU activation function. The output layer has the following number of neurons: ,in This represents the number of physical servers; 1 corresponds to a delay in scheduling actions. The output layer uses the Softmax activation function to generate the probability distribution of scheduling actions. This represents the scheduling action at time t. These represent the parameters of the policy network. Scheduling actions. The value ranges from 0 to J, where 0 indicates postponement of scheduling, and 1 to J indicates that the current highest priority task will be assigned to the physical server with the corresponding number. The policy network generates specific scheduling actions based on the probability distribution of scheduling actions. The sampling method is random sampling according to the probability distribution to ensure exploratory nature.

[0041] The value network Critic employs a similar multilayer perceptron (MLP) structure, with the input being the joint observation states. The output is the state value. The state value represents the expected value of the cumulative reward in the future under the current joint observation state. The hidden layer structure of the value network is the same as that of the policy network, and the output layer is a single neuron with no activation function, directly outputting the numerical value of the state value.

[0042] Step S135: After executing the scheduling action based on the scheduling policy, calculate the reward value, use the reward value to maximize the cumulative reward through the near-end policy optimization algorithm, and update the parameters of the feature extractor, graph attention network, and Actor-Critic network; let t=t+1.

[0043] In this embodiment, the system generates scheduling actions based on the policy network. In a simulation environment or a real cluster, scheduling is performed to assign the highest priority task to a specified physical server or postpone its scheduling. After executing the scheduling action, changes in the cluster state and feedback from task execution are observed, and the reward value is calculated. Reward Value Calculated using a composite reward function. The composite reward function includes an interference penalty term. Preferably, the composite reward function also includes a resource fragmentation penalty term. and waiting time penalty items The composite reward function is: A negative sign indicates that the larger the penalty, the smaller the reward.

[0044] In this embodiment, the design of the interference penalty term Pinter is the key innovation of this invention, used to quantify the degree of microarchitectural interference between tasks. The calculation process of the interference penalty term includes: Step S1351: Calculate the microarchitecture amplification factor of the allocation node based on the last-level cache miss rate of the allocation node of the highest priority task among the TOP-K tasks after the scheduling action is executed.

[0045] Specifically, regarding the task (Assuming it is the highest priority task), assuming it is assigned to a node Get Nodes Current last-level cache miss rate The microarchitecture scaling factor is defined as follows: .in This is the amplification factor, typically ranging from 5 to 20, with 10 being preferred. The amplification factor is set based on the sensitivity of the cache miss rate to performance. When the node When the cache miss rate is high, the microarchitecture amplification factor increases non-linearly, indicating that the node There is severe cache contention, making it unsuitable for assigning new tasks.

[0046] Step S1352: Perform inner product operation between the highest priority task and the multidimensional feature vector of each assigned task on the allocation node, and multiply the inner product operation result by the microarchitecture amplification factor of the allocation node to obtain the first calculation result of each assigned task.

[0047] Specifically, assigning nodes The set of assigned tasks running on is , For task set Index of internal tasks. (This refers to the process of indexing tasks.) Separately with the task set The inner product operation is performed on the multidimensional feature vectors of each task, and the inner product operation represents the similarity of resource competition between tasks. For task... and task set Tasks in Calculate the inner product of its multidimensional eigenvectors. The larger the inner product value, the more similar the resource requirements of the two tasks are, and the more intense the resource competition during runtime.

[0048] Step S1353: Accumulate the first calculation results of all assigned tasks of the assigned node to obtain the interference penalty term.

[0049] Specifically, let's assume the highest priority task Assigned to a node , node Assigned tasks The first calculation result is Accumulated task set The first calculation result of all assigned tasks yields the interference penalty term: Interference penalty item The larger the value, the more important the task. With nodes The higher the level of interference from existing tasks, the worse the quality of scheduling decisions.

[0050] Resource fragmentation penalty This is used to quantify the fragmentation of cluster resources. The calculation method involves calculating the standard deviation of the remaining resources across all nodes. A larger standard deviation indicates a more uneven resource distribution and a higher degree of fragmentation. (Waiting time penalty term) The penalty is applied to tasks that wait for extended periods. The calculation method involves accumulating the waiting times of all tasks awaiting scheduling, with longer waiting times resulting in greater penalties.

[0051] The system utilizes the Proximal Policy Optimization (PPO) algorithm to maximize cumulative rewards and update network parameters. PPO is a reinforcement learning algorithm based on policy gradients, which ensures training stability by limiting the magnitude of policy updates. The core idea of ​​PPO is to construct an alternative objective function, which consists of the product of the policy ratio and the dominance function. The policy ratio is defined as the ratio of the new policy probability to the old policy probability, and the dominance function is defined as the difference between the actual reward and the value estimate. The alternative objective function limits the policy ratio through a truncation operation. Within the range, To truncate the parameters, typical values ​​range from 0.1 to 0.3, with 0.2 being preferred. The PPO algorithm updates the policy network parameters by maximizing the substitution objective function. The value network parameters are updated by minimizing the value error.

[0052] Feature extractor parameters and Parameters of graph attention network and Parameters of the Actor-Critic network The learning rate is updated synchronously using the backpropagation algorithm, and the gradient descent learning rate is... Typical values ​​range from 0.0001 to 0.001, with 0.0003 being preferred. The update formula is: Parameter = Parameter + × Gradient, the gradient is calculated through automatic differentiation. The system records the state at the current time step. ,action and rewards , constitute empirical tuples ( , , The empirical tuples are stored in the empirical replay buffer, with a capacity of 10,000 to 100,000, preferably 50,000. Once a sufficient number of empirical tuples have accumulated in the buffer, the system randomly samples a batch of empirical tuples from the buffer, with a batch size of 32 to 256, preferably 128. The sampled empirical tuples are then used to calculate gradients and update the network parameters. Let t = t + 1, and proceed to the next time step to continue the training process.

[0053] Step S14: After training is completed, the decision network that sequentially connects the feature extractor, graph attention network and Actor-Critic network constitutes the scheduling model.

[0054] like Figure 2 and 8 As shown, the scheduling model consists of three cascaded neural network modules: the first stage is a feature extractor, which takes the time series of node state vectors as input and outputs the initial embedding vectors of the nodes; the second stage is a graph attention network, which takes the initial embedding vectors of all nodes and the cluster topology graph as input and outputs the global topology vector of the cluster; the third stage is the decision network (Actor) of the Actor-Critic network, which takes the joint observation state (a concatenation of the global topology vector of the cluster and the queue state matrix) as input and outputs the probability distribution of scheduling actions. The parameters of the three modules have been optimized during training, and the connected scheduling model does not need to be retrained and can be directly used for online scheduling inference.

[0055] The inference process of the scheduling model is as follows: Inputting the current node state vector time series and the queue of tasks to be scheduled, the initial node embedding vector is obtained through a feature extractor, and the global topology vector of the cluster is obtained through a graph attention network. This vector is then concatenated with the queue state matrix and input into the policy network. The policy network outputs the probability distribution of the scheduling action for the highest priority task, and the action with the highest probability is selected as the final scheduling decision for the highest priority task. The inference time of the scheduling model is in the millisecond range, meeting the real-time requirements of online scheduling.

[0056] This implementation constructs a cluster topology graph, introduces microarchitectural interference attributes, utilizes graph attention networks to process the topology structure, and combines Actor-Critic networks and the PPO algorithm for end-to-end training to achieve topology-aware intelligent scheduling of heterogeneous cloud container clusters. Compared with traditional scheduling methods, this embodiment can globally perceive the physical dependencies and interference relationships between nodes, accurately capture the underlying resource contention state, and significantly improve resource utilization, service quality assurance, and anti-interference capabilities.

[0057] In a preferred embodiment, step S1, constructing edges based on the connection relationships between nodes, includes: If there is a physical topological connection between two nodes, then an edge connecting the two nodes is constructed; and if the cache miss rates of the two nodes are positively correlated, then an edge connecting the two nodes is constructed.

[0058] If there is no physical topological connection between two nodes and the cache miss rates are not positively correlated, then there is no edge between the two nodes.

[0059] In this implementation, for physical topology connections, the execution entity queries the configuration database of the data center network management system to obtain the rack identifier and top rack switch identifier for each physical server. The rack identifier is in string format, for example, "Rack-A-01" represents rack number 1 in area A, and the top rack switch identifier is in string format, for example, "ToR-Switch-05" represents top rack switch number 5. For nodes... and nodes Compare the rack identifiers of the two nodes. If the rack identifiers are the same, it is determined that the two nodes are located in the same rack, a physical topology connection is established, and settings are configured. The system further compares the top-rack switch identifiers of the two nodes. If the top-rack switch identifiers are the same but the rack identifiers are different, it determines that the two nodes are connected to the same top-rack switch but are located in different racks. A physical topology connection is then established, and settings are configured. Physical topology reflects the physical proximity and network path dependence between nodes. Nodes located in the same rack share the power distribution unit and network switches within the rack, and there is a correlation between power failures and network congestion; nodes connected to the same top rack switch share uplink bandwidth, and there is a risk of network traffic contention.

[0060] The system continuously monitors the Last-Level Cache Miss Rate (LLC) metric for all nodes. The LLC is collected via hardware performance counters, which are hardware monitoring interfaces provided by modern processors, enabling the acquisition of statistical data on microarchitectural events with minimal overhead. The system maintains a length of [length missing] for each node. The cache miss rate time series, where each element corresponds to the cache miss rate for one sampling period, the sampling period being consistent with the state vector acquisition period, and the time series length... The typical value is 50 to 200, with 100 being preferred. For nodes and nodes The system extracts the time series of cache miss rates from both and calculates the Pearson correlation coefficient. : ; .

[0061] Set correlation coefficient threshold ,when At that time, determine the node and nodes The cache miss rate is significantly positively correlated with the interfering affinity connection, and the following settings are established. A positive correlation between cache miss rates and the two nodes indicates that their load patterns are similar, possibly running the same type of application or accessing the same dataset. Assigning tasks to both nodes simultaneously can easily lead to cache contention and memory bandwidth competition. Interference affinity connections reflect implicit interference relationships between nodes, providing microarchitectural constraints for scheduling decisions.

[0062] By simultaneously considering physical topological connections and interference affinity connections, the cluster topology graph can comprehensively encode the physical constraints and performance couplings between nodes, providing rich structured inputs for graph attention networks and improving the accuracy and comprehensiveness of topology awareness.

[0063] In a preferred embodiment, the feature extractor includes: A one-dimensional convolutional neural network is used to convolve the time series of the state vector of each node at time t in the cluster topology graph to obtain the local temporal fluctuation characteristics of that node at time t. The first activation function unit uses the first activation function to perform a nonlinear transformation on the local temporal fluctuation characteristics at node t to obtain the initial embedding vector at node t.

[0064] In this embodiment, the feature extractor uses a one-dimensional convolutional neural network (1D-CNN) to extract nodes. State vector time series The process involves processing the data. One-dimensional convolutional neural networks (1D-CNNs) utilize sliding convolutional kernels along the time dimension to extract local temporal fluctuation features. The number of convolutional kernels is F, typically ranging from 32 to 128, with 64 being preferred; the number of kernels determines the richness of the extracted features. The length of the convolutional kernel is L, typically ranging from 3 to 7, with 5 being preferred; the length of the kernel determines the temporal span of the receptive field. The stride of the convolutional operation is 1, and the padding method is same padding to ensure that the length of the output sequence is consistent with the length of the input sequence. The calculation process of the convolutional layer involves processing the state vector time series... Apply convolution kernels to each time window This yields local temporal fluctuation features, and the convolution kernel... The dimensions are F×L×d. A bias term is added after the convolution operation. The dimension of the bias term is F.

[0065] The first activation function unit uses the ReLU activation function to perform a nonlinear transformation on the convolution output. This function introduces nonlinearity and alleviates the gradient vanishing problem. Node The initial embedding vector at time t The calculation formula is: ; in, This represents the convolution operation. Initial embedding vector. The dimension is F, and the vector contains nodes. The load evolution patterns and microarchitectural state change trends within the historical time window provide rich node feature representations for subsequent graph attention network processing. and The learnable parameters are updated via backpropagation and gradient descent optimizer. The optimizer used is the Adam optimizer with a learning rate of 0.0003 and momentum parameters β1=0.9 and β2=0.999. During training, the feature extractor is jointly optimized with a graph attention network and an Actor-Critic network to learn the most suitable temporal feature representation for the scheduling task end-to-end.

[0066] By using a one-dimensional convolutional neural network and the ReLU activation function, the feature extractor can effectively extract local temporal fluctuation features in the time series of node state vectors, capture the periodic patterns and sudden changes in load, and provide high-quality node feature inputs for topology awareness and scheduling decisions.

[0067] In a preferred embodiment, such as Figure 5 As shown, the graph attention network includes: The interference propagation probability calculation unit uses a graph attention mechanism to process the initial embedding vector of a node and its neighboring nodes at time t based on a learnable linear transformation matrix and attention vector, and obtains the interference propagation probability of the node at time t from its neighboring nodes. The aggregation unit aggregates the initial embedding vectors of a node and its neighbors at time t based on the linear transformation matrix and the interference propagation probability of the node at time t, and obtains the new embedding vector of the node at time t. The gated recurrent unit layer performs global pooling on the new embedding vectors of all nodes at time t in the cluster topology graph to generate the cluster global topology vector at time t.

[0068] In this implementation, a graph attention network is used to process the initial embedding vectors of all nodes at time t to obtain the global topology vector of the cluster at time t.

[0069] For any node in the cluster topology graph and its neighboring nodes ∈ Neighbor node set Defined as a node There exist edges connecting all nodes. The system introduces a learnable linear transformation matrix. and attention vector Linear transformation matrix A linear transformation is performed on the initial embedding vector of the node to obtain the transformed feature representation. The purpose of the transformation is to map the node features to a space suitable for attention computation. For the node... and neighboring nodes Calculate the transformed features respectively and Then, the two feature vectors are concatenated, denoted as ||, to obtain the concatenated vector. Attention vector Perform an inner product operation with the concatenated vector to obtain the original relevance score. Original relevance score A nonlinear transformation is performed using the LeakyReLU activation function, which allows negative values ​​to pass through with a small slope, thus avoiding neuron death. The transformed score is then normalized using the Softmax function to obtain the attention coefficient. , It has a clear physical meaning, representing the "probability of interference propagation", that is, the neighbor. High load or high interference conditions cause nodes The possibility of performance degradation. The calculation formula is: Attention coefficient Representing neighboring nodes For the central node The interference propagation probability ranges from 0 to 1, and the sum of the attention coefficients of all neighboring nodes is 1. Attention coefficient The larger the value, the more likely it is to be a neighboring node. The state of the central node The greater the impact, the stronger the influence of neighboring nodes. Attention coefficient under high load or high interference conditions Automatically increasing, indicating neighboring nodes For the central node The degree of influence has increased.

[0070] The aggregation unit is based on the calculated attention coefficient. Perform a weighted aggregation operation to propagate interference information from the neighborhood to the central node. Aggregate all neighboring nodes The initial embedding vector, and the aggregation formula are: in The ReLU function is used as the non-linear activation function. The new embedding vector of the aggregated node at time t. Includes nodes The new embedding vector, along with the topological context information of its neighboring nodes, makes the node... It can perceive the distribution of noisy neighbors, thus possessing environmental perception capabilities at the micro level.

[0071] Gated cyclic unit layer GRU for new embedding vectors of all nodes at time t in the cluster topology graph Global pooling is performed to generate the cluster global topology vector at time t. The global pooling operation uses either average pooling or max pooling. Average pooling calculates the mean of the new embedding vectors of all nodes, while max pooling extracts the maximum value of the new embedding vectors of all nodes in each dimension. The input to the gated recurrent unit (GRU) layer is the sequence of new embedding vectors of all nodes, and the output is a fixed-dimensional cluster global topology vector. This global topology vector encapsulates the load hotspot distribution, resource fragmentation, and interference topology of the entire cluster, providing global context input for subsequent scheduling decisions.

[0072] The parameters of a graph attention network include a linear transformation matrix. Attention vector The weight matrix and bias vector of the GRU are defined. Parameters are updated using backpropagation and a gradient descent optimizer (Adam optimizer with a learning rate of 0.0003). During training, the graph attention network is jointly optimized with the feature extractor and the Actor-Critic network, learning the most suitable topology-aware representation for the scheduling task end-to-end. Through the graph attention mechanism and gated recurrent units, the graph attention network effectively aggregates the features of nodes and their neighbors, quantifies the probability of interference propagation between nodes, and generates a global topology vector that condenses the entire cluster state, providing global and topology-aware input for scheduling decisions.

[0073] This invention also discloses a scheduling method for heterogeneous cloud container clusters. In a preferred embodiment, please see... Figure 7 The method includes: Step S20: Collect the node's operational data and obtain the node's current state vector time series based on the node's operational data.

[0074] In this embodiment, such as Figure 3 As shown, the system collects real-time operational data from all physical servers in the heterogeneous cloud container cluster. This operational data includes static capacity attributes, dynamic load attributes, and microarchitectural interference attributes. For the first... A physical server, at a fixed time interval State vector of the second acquisition node The state vector includes nine metrics: number of CPU physical cores, total memory capacity, network interface card bandwidth limit, CPU utilization, memory utilization, network utilization, instructions per clock cycle, last-level cache miss rate, and memory bandwidth usage. The system saves the most recent... The state vectors at each time step constitute the state vector time series of the node at the current moment. The system normalizes the state vectors to eliminate the influence of different indicator units.

[0075] Step S21: Obtain the queue state matrix at the current moment based on the task buffer queue to be scheduled at the current moment.

[0076] Specifically, such as Figure 6 As shown, the system obtains the current task queue, which contains all container tasks waiting to be scheduled. For each task in the queue, the system extracts its multi-dimensional feature vector, including CPU requirements, memory requirements, and anti-interference sensitivity level. The system calculates a dynamic score for each task, comprehensively considering the fit operator, similarity density, and task waiting time. The system sorts the tasks in the queue in descending order according to the dynamic scores and selects the top K=20 tasks with the highest scores. The multi-dimensional feature vectors and dynamic scores of the selected TOP-K tasks are stacked to form the queue state matrix at the current moment.

[0077] Step S22: Input the time series of state vectors of all nodes in the current cluster topology graph and the queue state matrix into the scheduling model. The decision network of the Actor-Critic network in the scheduling model generates scheduling actions and executes the scheduling actions. The scheduling model is obtained according to the training method of the topology-aware heterogeneous cloud container cluster scheduling model provided in the above implementation method.

[0078] like Figure 8 As shown, the scheduling model comprises three cascaded neural network modules: a feature extractor, a graph attention network, and a decision network. The system inputs the time series of the state vectors of all nodes into the feature extractor. The feature extractor processes the time series using a one-dimensional convolutional neural network and the ReLU activation function to generate an initial embedding vector for each node. The system inputs the initial embedding vectors of all nodes and the cluster topology graph into the graph attention network. The graph attention network uses a graph attention mechanism to calculate the attention coefficients between nodes, performs a weighted aggregation operation, generates a new embedding vector for each node, and then performs global pooling through a gated recurrent unit layer to generate a global topology vector for the cluster. The system concatenates the global topology vector and the queue state matrix to form a joint observation state. The system inputs the joint observation state into the decision network, which adopts a multilayer perceptron structure, including an input layer, two hidden layers, and an output layer. The input layer receives the joint observation state; the first hidden layer has 384 neurons, the second hidden layer has 192 neurons, and the output layer has J+1 neurons, where J is the number of physical servers and 1 corresponds to a deferred scheduling action. The output layer uses the Softmax activation function to generate a probability distribution for scheduling actions. The system selects the action with the highest probability as the final scheduling decision for the highest priority task based on the probability distribution. The system executes scheduling actions through the application programming interface of the container orchestration system, calling the API in the Kubernetes system to create Pods and bind them to the specified nodes, thus completing the scheduling and deployment of tasks.

[0079] In a preferred embodiment, an online update mechanism is added to the scheduling method. The method further includes: calculating a reward value based on the feedback after executing the scheduling action, and using the reward value to update the parameters of the feature extractor, graph attention network, and actor-critic network of the scheduling model through a reinforcement learning algorithm.

[0080] In this implementation, after executing a scheduling action, the system continuously monitors changes in the cluster state and feedback on task execution. Feedback information includes task start latency, runtime latency, resource utilization, and service level target achievement status. The system calculates a reward value based on the feedback information. The reward value is calculated using a composite reward function, including interference penalties, resource fragmentation penalties, and waiting time penalties. The system records the state at the current time step. ,action and rewards , constitute empirical tuples ( , , The experience tuples are stored in the online experience replay buffer. The online experience replay buffer uses a first-in, first-out strategy and has a capacity of 10,000. When the buffer is full, the oldest experience tuple is deleted.

[0081] In this implementation, the system periodically samples a batch of experience tuples from the online experience replay buffer, with a batch size of 128. The system uses the sampled experience tuples to calculate the policy gradient and value error, and updates the parameters of the scheduling model using the near-end policy optimization algorithm (PPO).

[0082] The online update mechanism updates once every 1000 scheduling actions, balancing model adaptability and computational overhead. Online updates enable the scheduling model to continuously adapt to changes in cluster load and the evolution of task characteristics, maintaining the optimality and robustness of scheduling decisions. Through the online update mechanism, the scheduling method can continuously learn and optimize during actual operation, adapting to the dynamic changes of cloud container clusters and improving the long-term performance and stability of scheduling decisions.

[0083] The present invention also discloses a computer device, including a memory, a processor, and a computer program stored in the memory, wherein the processor executes the computer program to implement the steps of the above-described training method or scheduling method for a topology-aware heterogeneous cloud container cluster scheduling model.

[0084] The present invention also discloses an electronic device, in one embodiment of which the electronic device includes at least one processor; and a memory communicatively connected to the at least one processor; wherein the memory stores a computer program executable by the at least one processor, the computer program being executed by the at least one processor to enable the at least one processor to execute the topology-aware heterogeneous cloud container cluster scheduling model training method or scheduling method provided by the present invention.

[0085] like Figure 9 The diagram shown is a structural schematic of an electronic device for a topology-aware heterogeneous cloud container cluster scheduling model training method or scheduling method provided in an embodiment of the present invention. The electronic device may include a processor 10, a memory 11, a communication bus 12, and a communication interface 13, and may also include a computer program stored in the memory 11 and executable on the processor 10, such as a topology-aware heterogeneous cloud container cluster scheduling model training method or scheduling method program.

[0086] In some embodiments, the processor 10 may be composed of integrated circuits, such as a single packaged integrated circuit or multiple integrated circuits with the same or different functions, including combinations of one or more central processing units (CPUs), microprocessors, digital processing chips, graphics processors, and various control chips. The processor 10 is the control unit of the electronic device, connecting various components of the entire electronic device through various interfaces and lines. It executes programs or modules stored in the memory 11 (e.g., executing a topology-aware heterogeneous cloud container cluster scheduling model training method or scheduling method), and calls data stored in the memory 11 to perform various functions of the electronic device and process data.

[0087] The memory 11 includes at least one type of readable storage medium, including flash memory, portable hard drive, multimedia card, card-type memory (e.g., SD or DX memory), magnetic memory, magnetic disk, optical disk, etc. In some embodiments, the memory 11 can be an internal storage unit of an electronic device, such as a portable hard drive. In other embodiments, the memory 11 can be an external storage device of the electronic device, such as a plug-in portable hard drive, SmartMediaCard (SMC), SecureDigital (SD) card, FlashCard, etc. Furthermore, the memory 11 can include both internal and external storage units of the electronic device. The memory 11 can be used not only to store application software and various types of data installed on the electronic device, such as the code of a topology-aware heterogeneous cloud container cluster scheduling model training method or scheduling method program, but also to temporarily store data that has been output or will be output.

[0088] The communication bus 12 can be a Peripheral Component Interconnect (PCI) bus or an Extended Industry Standard Architecture (EISA) bus, etc. This bus can be divided into an address bus, a data bus, a control bus, etc. The bus is configured to enable communication between the memory 11 and at least one processor 10, etc.

[0089] Communication interface 13 is used for communication between the aforementioned electronic device and other devices, including a network interface and a user interface. Optionally, the network interface may include a wired interface and / or a wireless interface (such as a Wi-Fi interface, Bluetooth interface, etc.), typically used to establish communication connections between the electronic device and other electronic devices. The user interface may be a display, an input unit (such as a keyboard), or optionally, a standard wired or wireless interface. Optionally, in some embodiments, the display may be an LED display, a liquid crystal display, a touch-sensitive liquid crystal display, or an OLED (Organic Light-Emitting Diode) touchscreen, etc. The display may also be appropriately referred to as a screen or display unit, used to display information processed in the electronic device and to display a visual user interface.

[0090] In the description of this specification, the references to terms such as "an embodiment," "some embodiments," "example," "specific example," "a implementation," "a preferred implementation," or "some examples," etc., indicate that a specific feature, structure, material, or characteristic described in connection with that embodiment or example is included in at least one embodiment or example of the present invention. In this specification, the illustrative expressions of the above terms do not necessarily refer to the same embodiment or example. Furthermore, the specific features, structures, materials, or characteristics described may be combined in any suitable manner in one or more embodiments or examples.

[0091] Although embodiments of the invention have been shown and described, those skilled in the art will understand that various changes, modifications, substitutions and alterations can be made to these embodiments without departing from the principles and spirit of the invention, the scope of which is defined by the claims and their equivalents.

Claims

1. A training method for a topology-aware heterogeneous cloud container cluster scheduling model, characterized in that, The method includes: Using the physical servers of the heterogeneous cloud container cluster as nodes, edges are constructed based on the connection relationships between nodes to obtain the cluster topology graph; Collect node operation data, and obtain the state vector time series of node at time t based on the node operation data. Each state vector in the state vector time series includes a performance index characterizing the underlying resource contention. The queue state matrix at time t is obtained from the task buffer queue to be scheduled at time t. Iteratively execute the following steps until the training completion condition is met: The initial embedding vector at time t is obtained by processing the state vector time series of node t using a feature extractor. The initial embedding vectors of all nodes at time t are processed using a graph attention network to obtain the global topology vector of the cluster at time t. The joint observation state at time t is obtained based on the cluster global topology vector and queue state matrix at time t; Input the joint observation state at time t into the Actor-Critic network to generate the scheduling strategy; After executing the scheduling action based on the scheduling policy, the reward value is calculated. The cumulative reward is maximized using the reward value through the near-end policy optimization algorithm, and the parameters of the feature extractor, graph attention network, and Actor-Critic network are updated. Let t = t + 1. After training, the decision network, which connects the feature extractor, graph attention network, and actor-critic network in sequence, constitutes the scheduling model.

2. The method for training a topology-aware heterogeneous cloud container cluster scheduling model according to claim 1, characterized in that, The construction of edges based on the connection relationships between nodes includes: If there is a physical topological connection between two nodes, then construct an edge connecting the two nodes; as well as, If the cache miss rates of two nodes are positively correlated, then an edge connecting the two nodes is constructed.

3. The method for training a topology-aware heterogeneous cloud container cluster scheduling model according to claim 1, characterized in that, Each state vector includes at least one of three performance metrics: static capacity attribute, dynamic load attribute, and microarchitectural interference attribute. The microarchitectural interference attribute includes at least one of the following: instruction count per clock cycle, last-level cache miss rate, and memory bandwidth usage.

4. The method for training a topology-aware heterogeneous cloud container cluster scheduling model according to claim 1, characterized in that, The process of obtaining the queue state matrix at time t based on the task buffer queue at time t includes: Obtain the multidimensional feature vector of each task in the task queue to be scheduled at time t; The dynamic score for each task is calculated based on the fitness operator, similarity density, and task waiting time. The multidimensional feature vectors of the top-K tasks in the dynamic score ranking and the stacked dynamic scores form the queue state matrix at time t.

5. The method for training a topology-aware heterogeneous cloud container cluster scheduling model according to any one of claims 1-4, characterized in that, The feature extractor includes: A one-dimensional convolutional neural network is used to convolve the time series of the state vector of each node at time t in the cluster topology graph to obtain the local temporal fluctuation characteristics of that node at time t. The first activation function unit uses the first activation function to perform a nonlinear transformation on the local temporal fluctuation characteristics at node t to obtain the initial embedding vector at node t.

6. The method for training a topology-aware heterogeneous cloud container cluster scheduling model according to claim 5, characterized in that, The graph attention network includes: The interference propagation probability calculation unit uses a graph attention mechanism to process the initial embedding vector of a node and its neighboring nodes at time t based on a learnable linear transformation matrix and attention vector, and obtains the interference propagation probability of the node at time t from its neighboring nodes. The aggregation unit aggregates the initial embedding vectors of a node and its neighbors at time t based on the linear transformation matrix and the interference propagation probability of the node at time t, and obtains the new embedding vector of the node at time t. The gated recurrent unit layer performs global pooling on the new embedding vectors of all nodes at time t in the cluster topology graph to generate the cluster global topology vector at time t.

7. The method for training a topology-aware heterogeneous cloud container cluster scheduling model according to claim 5, characterized in that, The reward value is calculated using a composite reward function, which includes an interference penalty term. The calculation process for the interference penalty term includes: The microarchitecture amplification factor of the allocation node is calculated based on the last-level cache miss rate of the allocation node of the highest priority task among the TOP-K tasks after the scheduling action is executed. Perform an inner product operation between the highest priority task and the multidimensional feature vector of each assigned task on the allocation node, and multiply the inner product result by the microarchitecture amplification factor of the allocation node to obtain the first calculation result of each assigned task. The interference penalty term is obtained by summing the first calculation results of all assigned tasks of the assigned node.

8. A scheduling method for heterogeneous cloud container clusters, characterized in that, The method includes: Collect node operation data, and obtain the node's current state vector time series based on the node operation data; Obtain the queue state matrix at the current moment based on the task buffer queue to be scheduled; Input the time series of state vectors of all nodes in the current cluster topology graph and the queue state matrix into the scheduling model. The decision network of the Actor-Critic network in the scheduling model generates scheduling actions and executes the scheduling actions. The scheduling model is obtained according to the training method of the topology-aware heterogeneous cloud container cluster scheduling model according to any one of claims 1-7.

9. The scheduling method for heterogeneous cloud container clusters according to claim 8, characterized in that, The method further includes: calculating a reward value based on the feedback after executing the scheduling action, and using the reward value to update the parameters of the feature extractor, graph attention network, and Actor-Critic network of the scheduling model through a reinforcement learning algorithm.

10. A computer device comprising a memory, a processor, and a computer program stored in the memory, characterized in that, The processor executes the computer program to implement the steps of the method according to any one of claims 1-9.

Images