Computing resource scheduling method based on user demands and task priorities

Abstract

The invention discloses a computing resource scheduling method based on user demands and task priorities, which relates to the technical field of resource scheduling, and comprises the following steps: receiving a computing task request submitted by a user, analyzing and verifying explicit demand parameters and implicit demand parameters, and generating a standardized demand description object; acquiring cluster state data and external environment parameters in real time, constructing a user-task-environment three-dimensional feature tensor, and outputting a standardized feature vector group; and collecting a performance data flow of the container instance group, triggering an elastic scaling decision based on a pre-trained LSTM prediction model, dynamically adjusting cluster resource configuration and executing abnormal task rescheduling. According to the method, a user-task-environment three-dimensional feature tensor is constructed, and a dynamic mixed weighted priority score is generated in combination with a reinforcement learning model, so that space alignment and time sequence cumulative effect fusion of multi-dimensional features is realized.

Description

Technical Field

[0001] The present invention relates to the technical field of resource scheduling, and particularly to a computing resource scheduling method based on user requirements and task priorities. Background Art

[0002] In recent years, with the popularization of heterogeneous computing architectures and the rapid development of cloud-native technologies, task scheduling in distributed cluster environments has gradually shifted from static resource allocation to dynamic optimization. Traditional scheduling algorithms based on heuristic rules or fixed-priority queues can no longer meet the efficient utilization requirements of multi-modal tasks for hardware acceleration resources. The academic and industrial communities have proposed dynamic scheduling frameworks based on reinforcement learning for resource fragmentation integration, real-time environment perception, etc., and introduced topology-aware scheduling strategies into container orchestration engines. Existing solutions still have significant bottlenecks in heterogeneous resource dynamic matching and multi-dimensional environmental parameter joint modeling. Especially in the scenario of hardware accelerator fragmentation, it is difficult to achieve sub-millisecond alignment between resource allocation granularity and task requirements.

[0003] Current mainstream scheduling relies on offline historical data for static weight configuration and lacks the ability to respond online to real-time environmental fluctuations. In heterogeneous clusters, the utilization loss caused by resource fragmentation is relatively high, and the traditional priority scoring mechanism cannot effectively integrate the three-dimensional correlation features of user behavior patterns, task hardware acceleration requirements, and physical environment status. Such limitations directly lead to problems such as increased task queuing delays, decreased hardware energy efficiency ratio, and low abnormal task self-healing efficiency. Summary of the Invention

[0004] In view of the above existing problems, the present invention is proposed.

[0005] Therefore, the present invention provides a computing resource scheduling method based on user requirements and task priorities to solve the problems of low utilization rate of hardware acceleration resources and poor real-time performance of task scheduling in heterogeneous computing environments due to serious resource fragmentation and complex coupling of dynamic environmental parameters.

[0006] To solve the above technical problems, the present invention provides the following technical solutions:

[0007] In a first aspect, the present invention provides a computing resource scheduling method based on user requirements and task priorities, which includes receiving a computing task request submitted by a user, parsing and verifying explicit demand parameters and implicit demand parameters, and generating a standardized demand description object;

[0008] Obtaining cluster status data and external environmental parameters in real time, constructing a user-task-environment three-dimensional feature tensor, and outputting a standardized feature vector group;

[0009] Input the standardized feature vector group into the pre-trained reinforcement learning model, calculate the dynamic hybrid weighted priority score, and generate a priority task queue with timestamps;

[0010] According to the priority task queue, scan the cluster resource topology structure, perform resource allocation and microsecond-level reorganization operations on the remaining resource fragments, output the resource allocation map, create a container instance group with hardware acceleration constraints through the container orchestration engine, and inject real-time performance monitoring probes;

[0011] Collect the performance data stream of the container instance group, trigger elastic scaling decisions based on the pre-trained LSTM prediction model, dynamically adjust the cluster resource configuration, and perform abnormal task rescheduling.

[0012] As a preferred solution of the computing resource scheduling method based on user requirements and task priorities according to the present invention, wherein: receiving the computing task request submitted by the user, parsing and validating the explicit demand parameters and implicit demand parameters, and generating a standardized demand description object, the specific steps are as follows,

[0013] Receive the original computing task request submitted by the user through the declarative API interface, and obtain the explicit demand parameters;

[0014] Use a natural language processor to parse the unstructured description fields in the original computing task request and extract the implicit demand parameters;

[0015] Input the explicit demand parameters and implicit demand parameters into the demand verification engine, perform multi-dimensional cross-validation, and generate a standardized demand description object.

[0016] As a preferred solution of the computing resource scheduling method based on user requirements and task priorities according to the present invention, wherein: obtaining the cluster status data and external environment parameters in real time, constructing a user-task-environment three-dimensional feature tensor, and outputting a standardized feature vector group, the specific steps are as follows,

[0017] Obtain the cluster status data in real time through the probes deployed on the cluster nodes, synchronously access the external environment sensor network to obtain the external environment parameters, and generate a heterogeneous data stream with timestamps;

[0018] Input the heterogeneous data stream into the spatio-temporal alignment engine for multi-source data time synchronization, and output the jointly feature dataset after spatio-temporal alignment;

[0019] Separate the user dimension features, task dimension features, and environment dimension features from the jointly feature dataset, and construct user feature vectors, task feature vectors, and environment feature vectors respectively;

[0020] Perform dynamic interaction fusion, execute non-linear fusion calculation, construct a three-dimensional feature tensor of user-task-environment, perform slicing normalization processing, and output a standardized feature vector group.

[0021] As a preferred solution of the computing resource scheduling method based on user requirements and task priorities according to the present invention, wherein: inputting the standardized feature vector group into a pre-trained reinforcement learning model, calculating a dynamic hybrid weighted priority score, and generating a priority task queue with timestamps, the specific steps are as follows.

[0022] Input the standardized feature vector group into a hierarchical attention allocation mechanism, calculate a two-dimensional attention weight matrix through a user-task interaction layer and a task-environment adaptation layer, and output a fused attention weight.

[0023] Input the fused attention weight and cluster status data into a reinforcement learning model for pre-training, execute dynamic score calculation, and output a priority score value.

[0024] Perform conflict resolution calculation on the priority score value to generate a priority score sequence without time overlap; sort the priority score sequence in descending order of score value, inject nanosecond-level timestamps, and generate a priority task queue with timestamps.

[0025] As a preferred solution of the computing resource scheduling method based on user requirements and task priorities according to the present invention, wherein: according to the priority task queue, scan the cluster resource topology, perform resource allocation and microsecond-level reorganization operations on the remaining resource fragments, and output a resource allocation map, the specific steps are as follows.

[0026] Analyze the resource requirements in the priority task queue, and construct a three-dimensional resource topology tensor in combination with real-time cluster status data.

[0027] Based on the three-dimensional resource topology tensor, calculate the matching degree between the remaining resource fragments and the tasks to be allocated through a fragment integration objective function.

[0028] Convert the fragment integration objective function into a quadratic unconstrained binary optimization form, use a quantum annealing machine to solve for preliminary integration, and perform atomic resource reorganization operations to output a resource allocation map.

[0029] As a preferred solution of the computing resource scheduling method based on user requirements and task priorities according to the present invention, wherein: create a container instance group with hardware acceleration constraints through a container orchestration engine, and inject real-time performance monitoring probes, the specific steps are as follows.

[0030] Mark the accelerator type and resource quota according to the resource allocation map, and generate a container configuration description file with hardware acceleration constraints.

[0031] Invoke the node selector of the container orchestration engine to precisely match the container configuration description file with the physical topology labels of the cluster nodes, and create a container instance group on the target node group;

[0032] Inject real-time performance monitoring probes into the container instance group through the kernel bypass method.

[0033] As a preferred solution of the computing resource scheduling method based on user requirements and task priorities according to the present invention, wherein: collecting the performance data stream of the container instance group, triggering elastic scaling decisions based on the pre-trained LSTM prediction model, dynamically adjusting the cluster resource configuration, and performing abnormal task rescheduling, the specific steps are as follows,

[0034] Perform spatio-temporal alignment and normalization processing on the heterogeneous performance data stream collected by the real-time performance monitoring probe, and generate a multi-modal time series feature matrix after filling in the missing values;

[0035] Input the multi-modal time series feature matrix into the pre-trained LSTM prediction model to predict the performance data stream resource requirements of each container group in the future time domain, and output the demand prediction value with a confidence interval;

[0036] Generate an elastic scaling instruction set through Monte Carlo scenario sampling, calculate the KL divergence between the current resource state and the prediction value in real time, and perform abnormal task rescheduling if it exceeds the preset dynamic KL divergence threshold;

[0037] Migrate the container checkpoint snapshot to the topology-matching node through a secure encrypted channel, and generate a scheduling efficiency report through log analysis.

[0038] As a preferred solution of the computing resource scheduling method based on user requirements and task priorities according to the present invention, wherein: the heterogeneous performance data stream includes GPU video memory bandwidth, TPU matrix calculation unit utilization rate, and RDMA network latency metrics.

[0039] In a second aspect, the present invention provides a computer device, including a memory and a processor, wherein: the memory stores a computer program, and wherein: when the computer program is executed by the processor, it implements any step of the computing resource scheduling method based on user requirements and task priorities as described in the first aspect of the present invention.

[0040] In a third aspect, the present invention provides a computer-readable storage medium, on which a computer program is stored, and wherein: when the computer program is executed by the processor, it implements any step of the computing resource scheduling method based on user requirements and task priorities as described in the first aspect of the present invention.

[0041] The beneficial effects of the present invention are as follows: By constructing a three-dimensional feature tensor of user-task-environment, combining with a reinforcement learning model to generate a dynamic hybrid weighted priority score, the spatial alignment and temporal cumulative effect fusion of multi-dimensional features are realized. Based on the collaborative encoding of standardized requirement description objects and real-time cluster state data, the matching degree of hardware acceleration resource requirements and supply can be accurately quantified, and the continuous allocation probability of FPGA / GPU video memory blocks can be improved through a microsecond-level resource fragmentation reorganization algorithm. The pre-trained LSTM elastic scaling decision model analyzes the performance data stream of container instance groups, dynamically calculates the boundary conditions of resource topology constraints, and realizes the active prediction and thermal migration of abnormal tasks. The container instance group creation mechanism with hardware acceleration constraints ensures that compute-intensive tasks can be directly bound to the physical device with the optimal NUMA affinity. At the same time, the underlying hardware state transition events are captured through the injected real-time performance monitoring probes, providing the large-scale heterogeneous computing cluster with the ability of autonomous decision-making with millisecond-level response. BRIEF DESCRIPTION OF THE DRAWINGS

[0042] In order to more clearly illustrate the technical solutions of the embodiments of the present invention, the drawings required for the description of the embodiments will be briefly introduced below. Obviously, the drawings in the following description are only some embodiments of the present invention. For those of ordinary skill in the art, without creative efforts, other drawings can be obtained based on these drawings.

[0043] Figure 1 It is a flowchart of a computing resource scheduling method based on user requirements and task priorities in Embodiment 1;

[0044] Figure 2 It is a flowchart of three-dimensional feature modeling in Embodiment 1;

[0045] Figure 3 It is a flowchart of dynamic priority decision-making in Embodiment 1;

[0046] Figure 4 It is a flowchart of resource scheduling execution in Embodiment 1. DETAILED DESCRIPTION OF THE EMBODIMENTS

[0047] In order to make the above objects, features, and advantages of the present invention more obvious and understandable, the specific embodiments of the present invention will be described in detail below with reference to the accompanying drawings of the specification.

[0048] Many specific details are set forth in the following description in order to provide a thorough understanding of the present invention. However, the present invention may be implemented in other ways different from those described herein. Those skilled in the art can make similar extensions without departing from the connotation of the present invention. Therefore, the present invention is not limited by the specific embodiments disclosed below.

[0049] Second, the "one embodiment" or "embodiment" referred to herein means a specific feature, structure or characteristic that may be included in at least one implementation manner of the present invention. The "in one embodiment" that appears in different places in this specification does not all refer to the same embodiment, nor is it an individual or selectively mutually exclusive embodiment with other embodiments.

[0050] Embodiment 1, referring to Figures 1 to 4 , this embodiment provides a computing resource scheduling method based on user requirements and task priorities, including the following steps:

[0051] S1. Receive the computing task request submitted by the user, parse and verify the explicit requirement parameters and implicit requirement parameters, and generate a standardized requirement description object.

[0052] Furthermore, receive the original computing task request submitted by the user through the declarative API interface, and obtain the explicit requirement parameters;

[0053] Specifically, adopt the extended mechanism based on Kubernetes CRD to abstract the user request into a declarative resource object. The user defines the task requirements in YAML or JSON format, and the API Server parses and extracts the explicit requirement parameters in the structured fields, including core indicators such as resource type, scale requirement, and time sensitivity.

[0054] Adopt a natural language processor to parse the unstructured description fields in the original computing task request and extract the implicit requirement parameters;

[0055] Specifically, perform multi-level feature extraction on the text. Through intention recognition, parse the implicit logical relationship and modification structure in the task description, and identify the context features strongly associated with resource requirements; through domain-adaptive entity relationship graph matching, map the ambiguous expressions to standardized business scenario labels, quantify the implicit priority tendency and resource preference in the unstructured fields, and output the implicit requirement parameters.

[0056] The explicit requirement parameters include resource type encoding, scale requirement, and time sensitivity, and the implicit requirement parameters include business type label, enterprise credit rating, and historical task preference;

[0057] It should be noted that the resource type encoding refers to the hardware or service type identifier explicitly specified by the user. For example: GPU model (such as NVIDIA A100, V100), storage type (such as SSD, HDD or NVMe), and network bandwidth level (such as 10Gbps, 25Gbps);

[0058] The scale requirement refers to the quantified resource indicators clearly required by users. For example, computing resources (number of CPU cores (such as 16 cores), number of GPU cards (such as 4 cards)), memory capacity (64GB DDR4), and storage space (1TB NVMe SSD);

[0059] The time sensitivity refers to the classification of the tolerance of tasks to latency. For example, real-time tasks (latency < 100ms, such as high-frequency trading), near-real-time tasks (latency < 1s, such as video transcoding), and batch processing tasks (latency > 1h, such as offline data analysis);

[0060] The business type label refers to the task scenario identifier automatically classified through semantic analysis. For example, AI training (requiring multi-GPU collaboration), stream data processing (requiring high-throughput network), and cold storage backup (requiring high-capacity HDD);

[0061] The enterprise credit rating refers to the dynamic credit score evaluated based on historical behaviors. For example, high-credit enterprises (can overdraw 20% of the resource quota), medium-credit enterprises (require pre-authorization of resources), and low-credit enterprises (only allocate 50% of the applied resources);

[0062] The historical task preference refers to the implicit resource allocation tendency in the user's past tasks. For example, regional preference, time period preference, and software stack preference.

[0063] Input the explicit demand parameters and implicit demand parameters into the demand verification engine, perform multi-dimensional cross-verification, and generate a standardized demand description object.

[0064] Specifically, when inputting the explicit demand parameters and implicit demand parameters into the demand verification engine, construct a multi-dimensional cross-verification framework based on the logic rule engine and the graph neural network;

[0065] Parse the structured fields of the explicit parameters through the syntax tree, verify the format compliance and physical feasibility of the resource type and scale requirements, adopt time series feature alignment, match the periodic laws in the explicit time sensitivity and implicit task preferences through a sliding window, dynamically correct the time window weight of the resource requirements, and encode the verified parameters into a standardized demand description object with a hypercube structure using tensor fusion technology.

[0066] S2. Real-time obtain the cluster status data and external environment parameters, construct a three-dimensional feature tensor of user-task-environment, and output a standardized feature vector group.

[0067] Furthermore, real-time obtain the cluster status data through the probes deployed on the cluster nodes, synchronously access the external environment sensor network to obtain external environment parameters, and generate a heterogeneous data stream with timestamps;

[0068] Specifically, lightweight probes deployed on cluster nodes are used to capture the status of underlying hardware resources and task runtime metrics in real time. At the same time, a distributed environment sensor network is accessed to collect physical environment constraints, and a high-precision time synchronization protocol is used to align the clocks of multi-source data. External environment parameters are parsed from the original sensor messages through the TCP protocol stack and outlier filtering is performed. All data flows through a unified message queue middleware for buffering and priority grading. Time-series data cleaning and format standardization based on a sliding window are performed to eliminate data jitter caused by differences in sampling frequencies, and finally, a heterogeneous data stream with strictly aligned timestamps and multi-modal feature fusion is generated.

[0069] Cluster status data includes hardware resource status, network topology status, task running status, container instance status, and dynamic scheduling metrics. External environment parameters include user requirement parameters, task priority parameters, physical environment constraints, network environment parameters, and policy regulation parameters.

[0070] It should be noted that the hardware resource status refers to the real-time operation metrics of physical devices in the cluster, including computing resources, storage resources, and accelerator status.

[0071] The network topology status refers to the connection relationship and communication performance between cluster nodes, including connection topology (physical / logical link mapping relationship between nodes), transmission metrics, and routing policies.

[0072] The task running status refers to the real-time monitoring of the execution characteristics of tasks, including the lifecycle stage (queuing, scheduling, running, suspended), resource consumption, and runtime metrics.

[0073] The container instance status refers to the runtime environment information of containerized tasks, including resource allocation, health status, and dependency relationships.

[0074] The dynamic scheduling metrics refer to the real-time metrics that quantify the scheduling efficiency, including resource fragmentation rate, task queuing delay, and scheduling conflict rate.

[0075] User requirement parameters refer to the task requirements specified by users, including hardware acceleration requirements, data locality requirements, and compliance constraints.

[0076] Task priority parameters refer to the automatically generated priority labels, including business value level, deadline sensitivity, and resource dependency.

[0077] Physical environment constraints refer to the physical conditions that affect the operation of hardware, including temperature and humidity, power supply, and spatial location.

[0078] Network environment parameters refer to the impact of external network conditions on tasks, including cross-domain bandwidth, public network latency, and security policies (firewall rules, D Dos attack detection status).

[0079] The policy control parameters refer to the control variables for dynamically adjusting behaviors, including weight coefficients (such as the trade-off coefficient between resource utilization and task latency), elasticity thresholds (the resource water level lines for triggering automatic scaling (such as CPU > 80% for 5 consecutive minutes)), and fallback policies (the degradation policies when task scheduling fails).

[0080] Input the heterogeneous data stream into the spatio-temporal alignment engine for multi-source data time synchronization, and output the joint feature data set after spatio-temporal alignment;

[0081] Specifically, when processing the heterogeneous data stream through the spatio-temporal alignment engine, a hierarchical time axis correction architecture is adopted. Based on the Precision Time Protocol - Pulse Synchronization mechanism, nanosecond-level clock alignment is performed on the multi-source data stream to eliminate the timestamp offset caused by hardware clock drift or network latency. For the spatial dimension, graph embedding technology is used to map the physical topology coordinates to a low-dimensional manifold space. Combining the network hop count between nodes, the propagation delay compensation amount of the multi-hop transmission path is calculated, and the data stream after spatio-temporal compensation is recombined into a joint feature data set with strictly synchronized timestamps and topologically associated spatial positions through the tensor fusion layer.

[0082] It should be noted that the transmission path length is determined by measuring the network hop count between nodes. Combining historical statistics and real-time link status, the base delay of each hop is evaluated, and the fluctuating delay amount caused by network congestion or device load in the path is dynamically superimposed. Based on the topological structure relationship, spatial modeling of the cross-node transmission path is carried out, and the graph neural network is used to capture the implicit physical location correlation, automatically correcting the cumulative error of the hop count model, generating a delay compensation value that matches the real transmission loss, and ensuring that the heterogeneous data stream reaches sub-millisecond synchronization accuracy after spatio-temporal alignment.

[0083] The spatio-temporal alignment function, the expression is:

[0084]

[0085] ω(ξ) = e -λ(t-ξ) ;

[0086] In the formula, Γ represents the joint feature data set, Γ(t) represents the joint feature data set generated at the current time point t, t represents the current time point, τ represents the sliding window size, ξ represents the historical time point, ω represents the exponential decay weight function, λ represents the decay coefficient, λ = 0.1, m represents the data source category index, M represents the total number of data source categories, α m represents the credibility coefficient of the m-th type of data source, α m ∈[0,1], D m represents the original value of the m-th type of data source, represents the integral from time t - τ to the current time point t, Denoted as the cumulative sum of data source categories, and dξ is denoted as the historical time point variable.

[0087] Separate the user dimension features, task dimension features, and environment dimension features from the joint feature dataset, and construct user feature vectors, task feature vectors, and environment feature vectors respectively;

[0088] Specifically, when separating multi-dimensional features from the joint feature dataset through tensor decomposition technology, a hybrid architecture combining orthogonal projection decomposition and multi-head attention mechanism is adopted. By analyzing the global correlation structure of the joint feature data, matrix decomposition technology is used to decouple the hybrid feature space into three groups of non-interfering orthogonal vector spaces. Based on the data covariance relationship, the core directional differences in user behavior patterns, task attribute features, and environmental state changes are identified, and orthogonal bases are constructed through feature vector projection; an adaptive gating mechanism is used to extract dimension-specific information flows along different base directions, and the dynamic evolution laws of each dimension feature are captured by combining time series modeling. Finally, a vector representation space that is independent of users, tasks, and environments and semantically interpretable is formed; a gated residual network is used to separate the unique feature components of each dimension. The separated user, task, and environment features are respectively input into a bidirectional LSTM time series encoder to aggregate context semantic information along the time axis and generate a low-rank representation. The dimension difference is eliminated through a dynamic weight normalization layer to form three independent and orthogonal high-dimensional vector groups of user feature vectors, task feature vectors, and environment feature vectors.

[0089] It should be noted that in the determination of unique feature components, the attribution recognition of feature components is realized through multi-dimensional correlation analysis and semantic decoupling mechanism. The mutual information is used to quantify the correlation strength between features and user identities, task labels, and environmental indicators, and high contribution factors that are significantly correlated with a single dimension are screened; a gating mechanism combined with orthogonal projection is used to suppress cross-dimensional coupling interference components, and features that have strong interpretability only in specific contexts (such as user historical behavior sequences, task resource demand patterns, or environmental physical states) are retained; based on sparsity constraints and semantic interpretability verification, it is ensured that the separated user, task, and environment features only reflect the core characteristics of a single dimension in terms of statistical distribution and business logic.

[0090] The user feature vector, the expression is:

[0091]

[0092] In the formula, U represents the user feature vector, μ(R) represents the hardware acceleration score of the resource type, μ(R) ∈ [0, 10], R represents the resource type, σ(S) represents the normalized value of the task resource demand, S represents the current task resource demand, μ S represents the mean value of the historical task resource demand, μ Sis denoted as the standard deviation of the historical task resource requirements, k is denoted as the slope parameter of the Sigmoid function, k = 0.5, T is denoted as the task submission time point, T0 is denoted as the reference time offset, T0 = 6, V is denoted as the task value score, V ∈ [1, 5], C is denoted as the resource efficiency factor, C ∈ [0, 1], H is denoted as the historical task success rate, H ∈ [0, 1], ∈ is denoted as the smoothing factor, ∈ = 1e - 5.

[0093] It should be noted that the hardware acceleration score of the resource type is obtained by collecting the accelerator utilization rate in real time through the hardware performance counter and calculating based on the NVIDIA CUDA compatibility matrix; the normalized value of the task resource requirements is obtained by calculating based on the Z - score standardization expression; the resource efficiency factor collects the CPU / GPU power consumption through the RAPL interface and the FLOPS through the performance counter.

[0094] The task feature vector, the expression is:

[0095]

[0096] In the formula, J is denoted as the task feature vector, ρ is denoted as the proportion of matrix operation instructions in the task, ρ ∈ [0, 1], f is denoted as the execution times of conditional jump instructions per unit time, L is denoted as the measurement of the spatial locality of task memory access, L ∈ [0, 1], η is denoted as the degree of discreteness of non - contiguous memory access, η ∈ [0, 1], γ is denoted as the anti - zero constant, γ = 0.1, E” is denoted as the estimated computing energy consumption, E' is denoted as the measured memory access energy consumption, log(1 + f) is denoted as the logarithmic compression function.

[0097] It should be noted that the logarithmic compression function is used to suppress the numerical explosion of high - frequency branches; the estimated computing energy consumption is the task computing energy consumption predicted based on the instruction - level simulator; the measured memory access energy consumption is measured in real time through the PMC counter.

[0098] The environmental feature vector, the expression is:

[0099]

[0100] In the formula, E is denoted as the environmental feature vector, N is denoted as the total number of physical nodes in the cluster, i is denoted as the node index, u(i) is the GPU utilization rate of the i - th node, d(i) is the network hop count between the i - th node and the master node, p is denoted as the current power load rate of the computer room, p' is denoted as the heat dissipation efficiency, p' ∈ [0, 1], T max is denoted as the maximum temperature allowed in the computer room, G(s t ) is denoted as the security threat attenuation function, s t is denoted as the real - time security threat score, s t∈[0,1], c represents the network congestion index, and c ∈ [0,1].

[0101] It should be noted that the network hop count between the i-th node and the master node is obtained through the LLDP protocol; when the heat dissipation efficiency takes the value of 1, it indicates the optimal; the highest temperature allowed in the computer room is obtained in real time through sensors; the real-time security threat score is calculated through intrusion detection; when the network congestion index takes the value of 0, it indicates no congestion.

[0102] Perform dynamic interaction fusion, execute non-linear fusion calculation, construct a three-dimensional feature tensor of user-task-environment, perform slice normalization processing, and output a standardized feature vector group.

[0103] Specifically, based on the cross-attention calculation between user, task, and environment feature vectors, generate an inter-dimensional correlation weight matrix to capture the potential coupling relationship between user behavior patterns and task resource requirements, and at the same time model the dynamic impact of environmental constraints on task feasibility;

[0104] Screen the effective feature components of cross-dimensional interaction through a gating mechanism, suppress noise interference and retain high-order non-linear correlations; the fused user, task, and environment features are extended into a three-dimensional tensor structure along the three axes of user, task, and environment through residual connection and layer normalization operations, where each slice corresponds to the interaction state of a specific dimension; perform slice-level normalization on the three-dimensional tensor, divide the normalization domain according to user groups, task types, and environmental scenarios, eliminate the distribution offset between different slices, and output the standardized feature vector group.

[0105] Dynamic interaction fusion, expression:

[0106]

[0107] In the formula, Ψ represents the decision feature after dynamic interaction fusion, ⊙ represents element-wise multiplication of vectors, ∥E∥2 represents the L2 norm of the environmental state vector, β represents the time decay factor, β = 0.05, n represents the environmental dimension index, W n represents the dynamic weight matrix of the n-th environmental dimension, W n ∈[-1,1], Φ(U n ,E n ) represents the Gaussian kernel matching function, N” represents the number of dimensions of the environmental state vector, U n represents the mapping value of the user feature vector U on the n-th environmental dimension, E n represents the real-time observation value of the n-th environmental dimension of the environmental state vector E, KL(P∥Q) represents the KL divergence between the task demand distribution P and the cluster resource supply distribution Q, P represents the task demand distribution, and Q represents the cluster resource supply distribution.

[0108] Construct a three-dimensional feature tensor of user-task-environment, and the expression is:

[0109]

[0110] In the formula, F represents the three-dimensional interaction feature tensor, K represents the total number of users, M' represents the total number of tasks, and N' represents the number of environmental dimensions.

[0111] Preferably, by collecting the probe data of cluster nodes and the parameters of the external environmental sensor network in real time, a three-dimensional feature tensor of user-task-environment is constructed to achieve high-precision spatio-temporal alignment and dynamic interaction fusion of multi-source heterogeneous data. Deploy lightweight probes to capture the hardware resource status and task runtime metrics based on the event-driven architecture, synchronously integrate the physical environment constraints and network topology parameters, and use the hierarchical time axis correction and improved dynamic time warping algorithm to eliminate the temporal drift and spatial topology deviation of cross-modal data, and generate a strictly spatio-temporally synchronized joint feature dataset.

[0112] S3. Input the standardized feature vector group into the pre-trained reinforcement learning model, calculate the dynamic mixed weighted priority score, and generate a priority task queue with timestamps.

[0113] Furthermore, input the standardized feature vector group into the hierarchical attention allocation mechanism, calculate the two-dimensional attention weight matrix through the user-task interaction layer and the task-environment adaptation layer, and output the fused attention weight;

[0114] Specifically, when processing the standardized feature vector group through the hierarchical attention allocation mechanism, a two-branch parallel processing architecture is adopted. The user-task interaction layer calculates the semantic association matrix between the user feature vector and the task feature vector based on the multi-head attention mechanism, and captures the potential matching relationship between the user's historical behavior pattern and the task resource requirements;

[0115] The task-environment adaptation layer analyzes the compatibility weight between the task feature vector and the environmental feature vector through the gated attention network, and quantifies the dynamic adaptability of task execution to physical constraint conditions. The attention weight matrices output by the two branches are subjected to Hadamard product operation to generate a joint attention map, and then the low-confidence interaction nodes are filtered through the sparse gated unit to retain the attention connections with strong associations among users, tasks, and environments, and are fused into a unified attention weight matrix by using residual connection and layer normalization operations.

[0116] The user-task interaction layer, the expression is:

[0117]

[0118] In the formula, A represents the user-task interaction layer, Q u represents the user query matrix, K tDenote the task key matrix, d denotes the scaling factor, W' q Denote the weight matrix of the trainable query space q, q denotes the query space, W' k Denote the weight matrix of the trainable key space k, k denotes the key space.

[0119] It should be noted that the user query matrix is obtained by slicing the user dimension (the 0th dimension) of the input three-dimensional interaction feature tensor F through the weight matrix W' of the trainable query space q q The task key matrix is obtained by slicing the task dimension (the 1st dimension) of the input three-dimensional interaction feature tensor F through the weight matrix W' of the trainable key space k k The scaling factor takes the value of the dimension of the query / key vector (e.g., d = 64) to prevent the dot product from being too large and causing gradient explosion, W' q Map the user feature vector to the query space to represent the active demand characteristics of the user for the task. W' k Map the task feature vector to the key space to represent the passive requirement characteristics of the task for resources.

[0120] The task-environment adaptation layer, the expression is:

[0121]

[0122] In the formula, A' denotes the task-environment adaptation layer, σ denotes the Sigmoid activation function, σ ∈ (0, 1), j denotes the dimension index, E j Denote the jth dimension feature of the environmental state vector.

[0123] It should be noted that the jth dimension feature of the environmental state vector is collected in real time by the sensor.

[0124] Input the fused attention weight and cluster state data into the reinforcement learning model for pre-training, perform dynamic score calculation, and output the priority score value;

[0125] Specifically, when performing dynamic scoring calculation on the fused attention weights and cluster state data through a reinforcement learning model, the policy network receives the attention weights and real-time cluster state data, and models the historical attention weights and cluster state data through a gated recurrent unit (GRU) to capture the periodic pattern of task scheduling requests and the temporal correlation of resource release; the environmental state encoder maps physical metrics such as real-time node load and network topology into low-dimensional semantic vectors to represent the dynamic operation trend of the cluster; after cross-modal fusion, the policy network generates the probability distribution of candidate actions, such as preferentially scheduling to low-load nodes or delaying task execution, and finally combines Monte Carlo tree search to perform weighted sampling on high-return paths to achieve dynamic decision-making jointly driven by temporal dependence and spatial state; in the dynamic scoring stage, the state transition probability is adjusted according to the attention weights, and Monte Carlo tree search is used to explore high-value action paths and output the normalized priority scoring value.

[0126] Attention fusion, the expression is:

[0127] A” = ωA+(1 - ω)A';

[0128]

[0129] In the formula, A” represents the attention weight, ω represents the fusion weight, θ represents the adjustment factor, and θ = 0.5.

[0130] It should be noted that the fusion weight is used to dynamically balance the contributions of user-task interaction and task-environment adaptation; the adjustment factor is used to control the influence intensity of KL divergence on ω.

[0131] Dynamic priority scoring function, the expression is:

[0132]

[0133] In the formula, S'(t) represents the priority scoring value, τ represents the historical moment, A”(τ) represents the attention weight at the historical moment τ, A”(τ) ∈ [0,1], Φ(F(τ)) represents the feature mapping function, F(τ) represents the three-dimensional interaction feature tensor at the historical moment τ, ρ'(τ) represents the dynamic adjustment factor, β' represents the time decay factor, β' = 0.1, k' represents the task type index, W” k' represents the task type weight, W” k' = 0.8, represents the loss function L of task type k' k' for the gradient of parameter θ', ReLU represents the rectifier function, Var(F k' ) represents the variance of the feature tensor of task type k'.

[0134] Perform conflict resolution calculation on the priority score values to generate a priority score sequence without time overlap;

[0135] Specifically, quickly detect the overlapping areas of task time windows through an interval tree structure to identify task pairs with resource competition conflicts; for overlapping tasks, combine resource demand similarity (such as strong competition among GPU-intensive tasks) and the real-time supply status of the cluster (such as remaining resource volume and node load) to dynamically calculate the weight coefficients of conflict edges, construct a conflict matrix reflecting multi-dimensional competition intensity; use the dynamic programming algorithm to search for the maximum weight independent set in the conflict graph, preferentially retain high-score tasks and eliminate low-priority conflict nodes, and at the same time adjust the time offsets of the remaining tasks through the time window sliding strategy to ensure that the task execution intervals on the global time axis do not overlap; apply the Hungarian algorithm to optimize the bipartite graph matching of tasks and resources to generate a task sequence that strictly satisfies time non-overlap, resource mutual exclusion, and priority order.

[0136] Sort the priority score sequence in descending order of the score values and inject nanosecond-level timestamps to generate a priority task queue with timestamps.

[0137] Specifically, after sorting the priority score sequence in descending order through a global sorting algorithm, inject nanosecond-level timestamps for each task node based on the atomic clock synchronization protocol, and construct a priority task queue with timestamps through a time wheel data structure.

[0138] S4. According to the priority task queue, scan the cluster resource topology structure, perform resource allocation and microsecond-level reorganization operations on the remaining resource fragments, output a resource allocation map, create a container instance group with hardware acceleration constraints through a container orchestration engine, and inject real-time performance monitoring probes.

[0139] Furthermore, analyze the resource requirements in the priority task queue and construct a three-dimensional resource topology tensor in combination with real-time cluster status data;

[0140] Specifically, extract the structured resource requirement descriptions from the task queue, including core metrics such as computing unit type, storage capacity, and network bandwidth; the three dimensions of the three-dimensional tensor are respectively mapped to the physical node topology structure, resource category division, and dynamic performance index set, and the task requirements and node resource status are spatially aligned through tensor slicing operations to generate a high-dimensional dense tensor.

[0141] Based on the three-dimensional resource topology tensor, calculate the matching degree between the remaining resource fragments and the tasks to be allocated through the fragment integration objective function;

[0142] Specifically, the geometric distribution features of the fragment blocks are extracted through tensor slicing. A dynamic convolution kernel slides along the resource category dimension to calculate the compatibility score of the fragment blocks under multi-dimensional constraints. Meanwhile, the KL divergence is used to measure the statistical characteristic differences between the fragment distribution and the task requirements.

[0143] The objective function for fragment integration is expressed as:

[0144]

[0145] In the formula, G represents the value of the fragment integration objective function, X represents the resource allocation strategy matrix, ω' i' represents the weight of the i'-th fragment, V i' represents the projection matrix of the i'-th fragment, D i' represents the expected target value of the i'-th fragment, i' represents the fragment index, λ' represents the smoothing coefficient, λ' = 0.3, ΔX represents the change in resource allocation, ρ” represents the load volatility, ρ” ∈ (0, 1), Δt represents the time interval, and μ' represents the distribution matching coefficient, μ' = 0.7.

[0146] It should be noted that the resource allocation strategy matrix refers to the variable to be optimized, with a dimension of (number of resource types × number of time steps); the projection matrix of the fragment has a dimension of (number of resource types × feature dimension), which maps the resource allocation to the task requirement space; the expected target value of the fragment is generated by the task requirement prediction model; the smoothing coefficient controls the penalty intensity of the resource allocation change; the load volatility is calculated as the standard deviation of the node utilization rate.

[0147] The fragment integration objective function is transformed into a quadratic unconstrained binary optimization form, and a quantum annealing machine is used to solve the preliminary integration. The atomic resource recombination operation is performed, and the resource allocation map is output.

[0148] Specifically, the resource block allocation decision is abstracted as a binary variable, and the multi-dimensional constraints are encoded as a quadratic term coefficient matrix through Hamiltonian construction; the quadratic unconstrained binary optimization form is embedded in the quantum annealing machine framework, and the quantum tunneling effect is used to break through the local optimal solution limit; after the solution is completed, the atomic recombination operation is performed on the matching resource blocks based on the distributed transaction protocol, and the strong consistency of the cross-node resource locks is ensured through two-phase commit (2PC) to eliminate the partial commit risk during the allocation process, and the multi-dimensional resource allocation map is generated based on the quantum annealing result.

[0149] Based on the resource allocation map, the accelerator type and resource quota are marked, and a container configuration description file with hardware acceleration constraints is generated;

[0150] Specifically, parse the accelerator models and their resource quotas marked in the graph, map them to hardware constraint labels supported by the container orchestration engine, generate NUMA affinity policies based on topological coordinates, and declare the container's exclusive binding to the CPU core group, memory node, and accelerator physical location; embed the accelerator driver version and microcode loading instructions through annotation fields to ensure that compatible kernels and firmware are automatically mounted when the container instance is started, and generate a configuration description file.

[0151] Call the node selector of the container orchestration engine to accurately match the container configuration description file with the physical topology label of the cluster node, and create a container instance group on the target node group;

[0152] Specifically, through the hardware topology labels marked in the resource allocation map, the topology constraints are declared in the container configuration description file, driving the scheduler to traverse the metadata tag library of the cluster nodes to perform precise matching, and multi-level mapping of container configuration requirements and node labels is performed. For scenarios with multiple target conflicts, the Hungarian algorithm is used to solve the optimal node group; after a successful match, the scheduler executes a distributed transaction lock to reserve target resources based on the real-time load status of the node group, and calls the atomic deployment interface of the orchestration engine to batch create container instance groups on the target node group.

[0153] Inject real-time performance monitoring probes into a container instance group via a kernel bypass method.

[0154] Specifically, the eBPF program is dynamically mounted to the container namespace, and the probe code is injected into the virtual address space of the container instance through memory mapping. The probe transmits the original performance data directly to the user-state analysis engine through the RDMA network or shared memory channel, and combines with the timestamp counter (TSC) to achieve nanosecond event synchronization; the data stream is pushed to the distributed monitoring storage cluster through the zero-copy mechanism to reduce the full-link monitoring latency.

[0155] S5. Collect performance data streams of container instance groups, trigger elastic scaling decisions based on pre-trained LSTM prediction models, dynamically adjust cluster resource configuration, and perform abnormal task rescheduling.

[0156] Furthermore, the heterogeneous performance data streams collected by the real-time performance monitoring probes are temporally aligned and normalized, and after filling in missing values, a multimodal time series feature matrix is generated;

[0157] Specifically, the timestamps of each data source are aligned through a high-precision clock synchronization protocol, and the dynamic time warping algorithm is used to compensate for the sampling frequency differences, eliminating the timing misalignment caused by cross-device clock drift. Subsequently, the dimensionality differences are eliminated through Z-score normalization and quantile normalization, and the spatio-temporal Kriging interpolation is used to fill the data holes. The processed data stream is input into a multi-head self-attention encoder to extract the potential correlation patterns between cross-modal features, constructing a dense feature matrix with the row representing time points and the column representing multi-dimensional metrics (such as GPU SM utilization rate, RDMA retransmission rate, cache coherence events).

[0158] The multi-modal time series feature matrix is input into a pre-trained LSTM prediction model to predict the performance data stream resource requirements of each container group in the future time domain, and the demand prediction values with confidence intervals are output.

[0159] Specifically, the multi-modal time series feature matrix is sliced into continuous subsequences according to a time sliding window, the long-term and short-term dependencies are captured by stacking LSTM layers, and the multi-head self-attention module is used to dynamically weight the temporal contribution degrees of different modal features. The output layer integrates the Bayesian inference framework, and multiple groups of prediction results are generated through Monte Carlo Dropout sampling. The median value and the confidence interval boundaries of the resource requirements of each container group in the future time domain are calculated by combining the Bootstrap resampling technique.

[0160] An elastic scaling instruction set is generated through Monte Carlo scenario sampling, and the KL divergence between the current resource state and the predicted value is calculated in real time. If it exceeds the preset dynamic KL divergence threshold, the abnormal task rescheduling is executed.

[0161] It should be noted that the preset dynamic KL divergence threshold statistically analyzes the resource distribution characteristics under normal load based on the historical cluster state data, calculates the statistical distribution of the KL divergence and takes the high percentile value as the initial benchmark. The sensitivity of the dynamic KL divergence threshold is dynamically adjusted by combining the feedback of real-time monitored abnormal events (such as false alarm rate, missed detection rate), and at the same time, the dynamic KL divergence threshold is weighted and corrected according to the business priority (such as the SLA requirements of critical tasks). Finally, the effectiveness of the dynamic KL divergence threshold is verified through the stress test of simulating extreme scenarios, forming a dynamic judgment standard that takes into account both stability and self-adaptability.

[0162] Specifically, multiple groups of resource allocation scenarios are randomly generated based on the probability distribution of resource demand prediction, and the joint distribution of resource states under each scenario is calculated in combination with the Bayesian inference framework. The current cluster resource utilization rate, task queue load, and hardware health metrics are collected in real time, and the deviation degree from the predicted distribution is quantified through the KL divergence. If the dynamic KL divergence threshold is breached, the anomaly detection engine is triggered, the time window of the abnormal task is located through time series pattern matching, and the impact scope is determined in combination with the resource topology dependency analysis; atomic resource recovery and reallocation are performed, and migration is preferentially carried out to nodes with low fragmentation degree and high hardware compatibility. At the same time, a traffic shaping strategy is injected for a smooth transition.

[0163] The container checkpoint snapshot is migrated to the topology-matching node through a secure encrypted channel, and a scheduling efficiency report is generated through log analysis.

[0164] Specifically, an end-to-end encrypted tunnel is established through the quantum key distribution protocol, and the node identity is verified in combination with the hardware trust root to ensure the confidentiality and integrity of the snapshot data; after the snapshot data is incrementally compressed and differentially encoded, according to the topology label of the resource allocation map, the target node with the closest physical location and matching hardware configuration is selected, and microsecond-level transmission is achieved through the RDMA zero-copy technology. After the migration is completed, the distributed log collector aggregates the full-link operation logs and inputs them into the streaming processing engine for multi-dimensional correlation analysis to generate a visual efficiency report including resource utilization prediction, task restart success rate, and hardware failure heat map.

[0165] The heterogeneous performance data stream includes GPU video memory bandwidth, TPU matrix calculation unit utilization rate, and RDMA network latency metrics.

[0166] It should be noted that the GPU video memory bandwidth refers to the maximum rate at which the video memory controller exchanges data with the GPU computing core within a unit of time, which is jointly determined by the video memory type, bit width, and frequency.

[0167] The TPU matrix calculation unit utilization rate refers to the proportion of time for performing matrix multiplication and addition operations, reflecting the hardware acceleration efficiency.

[0168] The RDMA network latency metric refers to the one-way transmission time of data from the sending-end memory to the receiving-end memory, which is affected by network protocols, switch queue depth, and congestion control algorithms.

[0169] This embodiment also provides a computer device applicable to the case of a computing resource scheduling method based on user requirements and task priorities, including: a memory and a processor; the memory is used to store computer-executable instructions, and the processor is used to execute the computer-executable instructions to implement the computing resource scheduling method based on user requirements and task priorities as proposed in the above embodiment.

[0170] The computer device may be a terminal, which includes a processor, a memory, a communication interface, a display screen, and an input device connected via a system bus. Among them, the processor of the computer device is used to provide computing and control capabilities. The memory of the computer device includes a non-volatile storage medium and an internal memory. The non-volatile storage medium stores an operating system and computer programs. The internal memory provides an environment for the operation of the operating system and computer programs in the non-volatile storage medium. The communication interface of the computer device is used to communicate with external terminals in a wired or wireless manner, and the wireless manner can be implemented through WIFI, carrier networks, NFC (Near Field Communication), or other technologies. The display screen of the computer device can be a liquid crystal display screen or an electronic ink display screen. The input device of the computer device can be a touch layer covering the display screen, or buttons, trackballs, or touchpads provided on the housing of the computer device, or an external keyboard, touchpad, or mouse, etc.

[0171] This embodiment also provides a storage medium, on which a computer program is stored. When the program is executed by a processor, it implements the computing resource scheduling method based on user requirements and task priorities as proposed in the above embodiment; the storage medium can be implemented by any type of volatile or non-volatile storage device or a combination thereof, such as static random access memory (Static Random Access Memory, abbreviated as SRAM), electrically erasable programmable read-only memory (Electrically Erasable Programmable Read-Only Memory, abbreviated as EEPROM), erasable programmable read-only memory (Erasable Programmable Read Only Memory, abbreviated as EPROM), programmable read-only memory (Programmable Red-Only Memory, abbreviated as PROM), read-only memory (Read-Only Memory, abbreviated as ROM), magnetic memory, flash memory, magnetic disks, or optical discs.

[0172] In summary, the present invention realizes the spatial alignment of multi-dimensional features and the fusion of temporal cumulative effects by constructing a three-dimensional feature tensor of user-task-environment and generating a dynamic hybrid weighted priority score in combination with a reinforcement learning model. Based on the collaborative encoding of the standardized demand description object and the real-time cluster state data, the matching degree of the hardware acceleration resource demand and supply can be accurately quantified, and the continuous allocation probability of the FPGA / GPU video memory block is improved through the microsecond-level resource fragmentation reorganization algorithm. The pre-trained LSTM elastic scaling decision model dynamically calculates the boundary conditions of the resource topology constraint by analyzing the performance data stream of the container instance group, and realizes the active prediction and hot migration of abnormal tasks. The container instance group creation mechanism with hardware acceleration constraints is adopted to ensure that the compute-intensive tasks can be directly bound to the physical device with the optimal NUMA affinity. At the same time, the underlying hardware state transition events are captured by the injected real-time performance monitoring probes, providing the large-scale heterogeneous computing cluster with the autonomous decision-making ability with millisecond-level response.

[0173] It should be noted that the above embodiments are only used to illustrate the technical solutions of the present invention and not to limit them. Although the present invention has been described in detail with reference to the preferred embodiments, those of ordinary skill in the art should understand that the technical solutions of the present invention can be modified or equivalently replaced without departing from the spirit and scope of the technical solutions of the present invention, and they should all be covered by the scope of the claims of the present invention.

Claims

1. A computing resource scheduling method based on user requirements and task priorities, characterized in that: including Receiving a computing task request submitted by a user, parsing and validating explicit requirement parameters and implicit requirement parameters, and generating a standardized requirement description object; Obtaining cluster status data and external environment parameters in real time, constructing a three-dimensional user-task-environment feature tensor, and outputting a standardized feature vector group; Inputting the standardized feature vector group into a pre-trained reinforcement learning model, calculating a dynamic hybrid weighted priority score, and generating a priority task queue with timestamps; According to the priority task queue, scanning the cluster resource topology structure, performing resource allocation and microsecond-level reorganization operations on the remaining resource fragments, outputting a resource allocation map, creating a container instance group with hardware acceleration constraints through a container orchestration engine, and injecting real-time performance monitoring probes; Collecting the performance data stream of the container instance group, triggering an elastic scaling decision based on a pre-trained LSTM prediction model, dynamically adjusting the cluster resource configuration, and performing abnormal task rescheduling.

2. The computing resource scheduling method based on user requirements and task priorities according to claim 1, characterized in that: The step of receiving a computing task request submitted by a user, parsing and validating explicit requirement parameters and implicit requirement parameters, and generating a standardized requirement description object is as follows. Receiving the original computing task request submitted by the user through a declarative API interface and obtaining explicit requirement parameters; Using a natural language processor to parse the unstructured description fields in the original computing task request and extract implicit requirement parameters; Inputting the explicit requirement parameters and implicit requirement parameters into a requirement verification engine, performing multi-dimensional cross-verification, and generating a standardized requirement description object.

3. The computing resource scheduling method based on user requirements and task priorities according to claim 2, wherein: The step of obtaining cluster status data and external environment parameters in real time, constructing a three-dimensional user-task-environment feature tensor, and outputting a standardized feature vector group is as follows. Obtaining cluster status data in real time through probes deployed on cluster nodes, synchronously accessing an external environment sensor network to obtain external environment parameters, and generating a heterogeneous data stream with timestamps; Inputting the heterogeneous data stream into a spatio-temporal alignment engine for multi-source data time synchronization, and outputting a jointly feature dataset after spatio-temporal alignment; Separating user-dimensional features, task-dimensional features, and environment-dimensional features from the jointly feature dataset, and respectively constructing a user feature vector, a task feature vector, and an environment feature vector; Performing dynamic interaction fusion, performing non-linear fusion calculation, constructing a three-dimensional user-task-environment feature tensor, performing slice normalization processing, and outputting a standardized feature vector group.

4. The computing resource scheduling method based on user requirements and task priorities according to claim 3, characterized in that: The step of inputting the standardized feature vector group into a pre-trained reinforcement learning model, calculating a dynamic hybrid weighted priority score, and generating a priority task queue with timestamps is as follows. Inputting the standardized feature vector group into a hierarchical attention allocation mechanism, calculating a two-dimensional attention weight matrix through a user-task interaction layer and a task-environment adaptation layer, and outputting a fused attention weight; Inputting the fused attention weight and cluster status data into a reinforcement learning model for pre-training, performing dynamic score calculation, and outputting a priority score value; Performing conflict resolution calculation on the priority score value to generate a non-overlapping priority score sequence in time; Sorting the priority score sequence in descending order of the score value, injecting nanosecond-level timestamps, and generating a priority task queue with timestamps.

5. The computing resource scheduling method based on user requirements and task priorities according to claim 4, wherein: According to the priority task queue, scan the cluster resource topology structure, perform resource allocation and microsecond-level reorganization operations on the remaining resource fragments, and output a resource allocation map. The specific steps are as follows: Parse the resource requirements in the priority task queue, and construct a three-dimensional resource topology tensor in combination with real-time cluster status data; Based on the three-dimensional resource topology tensor, calculate the matching degree between the remaining resource fragments and the tasks to be allocated through the fragment integration objective function; Convert the fragment integration objective function into a quadratic unconstrained binary optimization form, use a quantum annealing machine to solve the preliminary integration, perform an atomic resource reorganization operation, and output a resource allocation map.

6. The computing resource scheduling method based on user requirements and task priorities according to claim 5, wherein: Create a container instance group with hardware acceleration constraints through a container orchestration engine, and inject real-time performance monitoring probes. The specific steps are as follows: Mark the accelerator type and resource quota according to the resource allocation map, and generate a container configuration description file with hardware acceleration constraints; Call the node selector of the container orchestration engine to accurately match the container configuration description file with the physical topology labels of the cluster nodes, and create a container instance group on the target node group; Inject real-time performance monitoring probes into the container instance group through the kernel bypass method.

7. The computing resource scheduling method based on user requirements and task priorities according to claim 6, characterized in that: Collect the performance data stream of the container instance group, trigger elastic scaling decisions based on a pre-trained LSTM prediction model, dynamically adjust the cluster resource configuration, and perform abnormal task rescheduling. The specific steps are as follows: Perform spatio-temporal alignment and normalization processing on the heterogeneous performance data stream collected by the real-time performance monitoring probe. After filling in the missing values, generate a multi-modal time series feature matrix; Input the multi-modal time series feature matrix into the pre-trained LSTM prediction model to predict the performance data stream resource requirements of each container group in the future time domain, and output demand prediction values with confidence intervals; Generate an elastic scaling instruction set through Monte Carlo scenario sampling, calculate the KL divergence between the current resource state and the prediction value in real time, and perform abnormal task rescheduling if it exceeds the preset dynamic KL divergence threshold; Migrate the container checkpoint snapshot to the topology-matching node through a secure encrypted channel, and generate a scheduling efficiency report through log analysis.

8. The computing resource scheduling method based on user requirements and task priorities according to claim 7, characterized in that: The heterogeneous performance data stream includes GPU video memory bandwidth, TPU matrix calculation unit utilization rate, and RDMA network latency metrics.

9. A computer device, comprising a memory and a processor, the memory storing a computer program, characterized in that: When the processor executes the computer program, it implements the steps of the computing resource scheduling method based on user needs and task priorities as described in any one of claims 1 to 8.

10. A computer-readable storage medium having a computer program stored thereon, characterized in that: When the computer program is executed by the processor, it implements the steps of the computing resource scheduling method based on user needs and task priorities as described in any one of claims 1 to 8.

Images