A method for scheduling computing resources based on user's requirements and task priorities

Abstract

The application discloses a kind of computing resource scheduling methods based on user's demand and task priority, it is related to resource scheduling technical field, including, receiving the computing task request submitted by user, explicit demand parameter and implicit demand parameter are parsed and verified, and standardization demand description object is generated;Real-time acquisition cluster state data and external environment parameter, construct user-task-environment three-dimensional feature tensor, output standardization feature vector group;The performance data flow of container instance group is collected, and the pre-trained LSTM prediction model is triggered to trigger elastic scaling decision, and dynamically adjusts cluster resource configuration and executes abnormal task rescheduling.The application constructs user-task-environment three-dimensional feature tensor, and generates dynamic mixed weighted priority score in combination with reinforcement learning model, realizes the space alignment of multidimensional feature and time sequence cumulative effect fusion.

Description

TECHNICAL FIELD

[0001] The present application relates to the technical field of resource scheduling, in particular to a computing resource scheduling method based on user demand and task priority. BACKGROUND

[0002] In recent years, with the popularity of heterogeneous computing architecture and the rapid development of cloud native technology, task scheduling in distributed cluster environment gradually shifts from static resource allocation to dynamic optimization. Traditional scheduling algorithms based on heuristic rules or fixed priority queues cannot meet the efficient utilization of hardware acceleration resources by multi-modal tasks. The academic and industrial communities have proposed dynamic scheduling frameworks based on reinforcement learning for resource fragmentation integration and real-time environment perception, and introduced topology-aware scheduling strategies in container orchestration engines. The existing solutions still have significant bottlenecks in dynamic matching of heterogeneous resources and joint modeling of multi-dimensional environmental parameters, especially in the context of hardware accelerator fragmentation, where the resource allocation granularity and task demand cannot be aligned at sub-millisecond level.

[0003] Current mainstream scheduling relies on offline historical data for static weight configuration, lacking online response capability to real-time environmental fluctuations. The utilization loss caused by resource fragmentation in heterogeneous clusters is high, and the traditional priority scoring mechanism cannot effectively integrate the three-dimensional correlation characteristics of user behavior patterns, task hardware acceleration requirements and physical environment status. Such limitations directly lead to increased task queuing delay, decreased hardware energy efficiency and low efficiency of abnormal task self-healing. SUMMARY

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

[0005] Therefore, the present application provides a computing resource scheduling method based on user demand and task priority to solve the problems of low utilization of hardware acceleration resources and poor real-time performance of task scheduling caused by severe resource fragmentation and complex coupling of dynamic environmental parameters in heterogeneous computing environments.

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

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

[0008] Real-time acquisition of cluster state data and external environmental parameters, construction of a user-task-environment three-dimensional feature tensor, and output of 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 timestamped priority task queue;

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

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

[0012] As a preferred scheme of the computing resource scheduling method based on user demand and task priority, wherein: the received user submitted computing task request is parsed and verified, and the explicit demand parameter and the implicit demand parameter are generated, and the specific steps are as follows,

[0013] The original computing task request submitted by the user is received through the declarative API interface, and the explicit demand parameter is obtained;

[0014] The natural language processor is used to parse the unstructured description field in the original computing task request, and the implicit demand parameter is extracted;

[0015] The explicit demand parameter and the implicit demand parameter are input into the demand verification engine, and multi-dimensional cross verification is performed to generate a standardized demand description object.

[0016] As a preferred scheme of the computing resource scheduling method based on user demand and task priority, wherein: the real-time acquisition of cluster state data and external environment parameters, the construction of user-task-environment three-dimensional feature tensor, and the output of standardized feature vector group are realized, and the specific steps are as follows,

[0017] The probe deployed on the cluster node is used to acquire the cluster state data in real time, and the external environment sensor network is used to access the external environment parameters in real time, and a timestamped heterogeneous data stream is generated;

[0018] The heterogeneous data stream is input into the space-time alignment engine, and multi-source data time synchronization is performed to output a joint feature data set after space-time alignment;

[0019] The user dimension feature, the task dimension feature and the environment dimension feature are separated from the joint feature data set, and the user feature vector, the task feature vector and the environment feature vector are constructed respectively;

[0020] Perform dynamic interactive fusion, execute nonlinear fusion calculation, construct user-task-environment three-dimensional feature tensor, perform slice normalization processing, and output standardized feature vector group.

[0021] As a preferred scheme of the computing resource scheduling method based on user demand and task priority according to the application, wherein: the standardized feature vector group is input into the pre-trained reinforcement learning model, the dynamic mixed weighted priority score is calculated, and the priority task queue with timestamp is generated, the specific steps are as follows,

[0022] The standardized feature vector group is input into the hierarchical attention allocation mechanism, the two-dimensional attention weight matrix is calculated through the user-task interaction layer and the task-environment adaptation layer, and the fusion attention weight is output.

[0023] The fusion attention weight and the cluster state data are input into the reinforcement learning model for pre-training, dynamic score calculation is performed, and the priority score value is output.

[0024] The priority score value is calculated for conflict resolution, and the priority score sequence without time overlap is generated; the priority score sequence is arranged in descending order of score value, and nanosecond-level timestamp is injected to generate the priority task queue with timestamp.

[0025] As a preferred scheme of the computing resource scheduling method based on user demand and task priority according to the application, wherein: according to the priority task queue, the cluster resource topology structure is scanned, the resource allocation and microsecond-level reorganization operation are performed on the remaining resource fragments, and the resource allocation atlas is output, the specific steps are as follows,

[0026] The resource demand in the priority task queue is analyzed, and a three-dimensional resource topology tensor is constructed combined with real-time cluster state data.

[0027] Based on the three-dimensional resource topology tensor, the matching degree of the remaining resource fragments and the to-be-allocated tasks is calculated through the fragment integration target function.

[0028] The fragment integration target function is converted into a quadratic unconstrained binary optimization form, a quantum annealing machine is used to solve the preliminary integration, an atomized resource reorganization operation is performed, and the resource allocation atlas is output.

[0029] As a preferred scheme of the computing resource scheduling method based on user demand and task priority according to the application, wherein: the container instance group with hardware acceleration constraint is created through the container orchestration engine, and real-time performance monitoring probe is injected, the specific steps are as follows,

[0030] According to the resource allocation atlas, the accelerator type and resource quota are marked, and the container configuration description file with hardware acceleration constraint is generated.

[0031] The node selector of the container orchestration engine is called to accurately match the container configuration description file with the physical topology label of the cluster node, and a container instance group is created on the target node group.

[0032] Real-time performance monitoring probes are injected into the container instance group through a kernel bypass method.

[0033] As a preferred solution of the computing resource scheduling method based on user demand and task priority, the performance data stream of the container instance group is collected, the pre-trained LSTM prediction model is triggered to make an elastic scaling decision, the cluster resource configuration is dynamically adjusted, and abnormal task rescheduling is performed.

[0034] The heterogeneous performance data stream collected by the real-time performance monitoring probe is subjected to spatio-temporal alignment and normalization processing, and after filling in the missing values, a multi-modal time series feature matrix is generated.

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

[0036] The elastic scaling instruction set is generated by Monte Carlo scene sampling, the KL divergence of the current resource state and the predicted value is calculated in real time, and if it exceeds the preset dynamic KL divergence threshold, abnormal task rescheduling is performed.

[0037] The container checkpoint snapshot is migrated to the topology matching node through a secure encrypted channel, log analysis is performed to generate a scheduling efficiency report.

[0038] As a preferred solution of the computing resource scheduling method based on user demand and task priority, the heterogeneous performance data stream includes GPU memory bandwidth, TPU matrix computation unit utilization, and RDMA network delay indicators.

[0039] In a second aspect, the present application provides a computer device comprising a memory and a processor, wherein the memory stores a computer program, and wherein the computer program is executed by the processor to implement any step of the computing resource scheduling method based on user demand and task priority according to the first aspect of the present application.

[0040] In a third aspect, the present application provides a computer readable storage medium having a computer program stored thereon, wherein the computer program is executed by a processor to implement any step of the computing resource scheduling method based on user demand and task priority according to the first aspect of the present application.

[0041] The application has the beneficial effects that: by constructing a user-task-environment three-dimensional feature tensor, a dynamic mixed weighted priority score is generated combining a reinforcement learning model, multi-dimensional feature space alignment and time sequence cumulative effect fusion are realized. Based on the collaborative coding of standardized demand description objects and real-time cluster state data, the matching degree of hardware acceleration resource demand and supply can be accurately quantified, and the continuous allocation probability of FPGA / GPU memory blocks is improved through microsecond-level resource fragment reorganization algorithm. The pre-trained LSTM elastic scaling decision model analyzes the performance data stream of the container instance group, dynamically solves the resource topology constraint boundary condition, and realizes the active prediction and hot migration of abnormal tasks. The container instance group creation mechanism constrained by hardware acceleration ensures that compute-intensive tasks can be directly bound to the physical device with optimal NUMA affinity, and the real-time performance monitoring probe is injected to capture the bottom layer hardware state transition event, providing millisecond-level response autonomous decision-making capability for large-scale heterogeneous computing clusters. BRIEF DESCRIPTION OF DRAWINGS

[0042] In order to more clearly illustrate the technical solutions of the embodiments of the application, the drawings needed in the embodiment description will be briefly introduced. Obviously, the drawings in the following description are only some embodiments of the application, and other drawings can be obtained by those skilled in the art without creative labor.

[0043] Fig. 1 Flowchart for the user-based demand and task priority calculation resource scheduling method in embodiment 1;

[0044] Fig. 2 Flowchart for three-dimensional feature modeling in embodiment 1;

[0045] Fig. 3 Flowchart for dynamic priority decision in embodiment 1;

[0046] Fig. 4 Flowchart for resource scheduling execution in embodiment 1. DETAILED DESCRIPTION

[0047] In order to make the above-mentioned purposes, features and advantages of the application more obvious and easy to understand, the specific embodiments of the application will be described in detail below with reference to the drawings in the specification.

[0048] In the following description, many specific details are set forth in order to provide a thorough understanding of the application, but the application can also be implemented in other ways different from those described herein, and those skilled in the art can make similar generalizations without departing from the connotation of the application, therefore the application is not limited to the specific embodiments disclosed below.

[0049] Second, the "one embodiment" or "an embodiment" referred to herein means a specific feature, structure, characteristic, or combination of features and characteristics described herein that can be included in at least one implementation of the application. The various appearances of "in one embodiment" or "in an embodiment" in the specification do not all refer to the same embodiment, although they can.

[0050] Embodiment 1, reference Figs. 1-4 The embodiment provides a computing resource scheduling method based on user demand and task priority, including the following steps:

[0051] S1, receiving a user-submitted computing task request, parsing and verifying explicit demand parameters and implicit demand parameters, and generating a standardized demand description object.

[0052] Further, the original computing task request submitted by the user is received through the declarative API interface, and the explicit demand parameters are obtained;

[0053] Specifically, an extension mechanism based on Kubernetes CRD is used to abstract the user request into a declarative resource object. The user defines the task demand in YAML or JSON format, and the explicit demand parameters in the structured field are parsed and extracted by the API Server, including resource type, scale demand, and time sensitivity, and other core indicators.

[0054] A natural language processor is used to parse the unstructured description field in the original computing task request, and extract implicit demand parameters;

[0055] Specifically, multi-level feature extraction is performed on the text, the implicit logical relationship and modification structure in the task description are parsed through intent recognition, and the context features strongly associated with resource demand are identified. Through the matching of the domain adaptive entity relationship graph, the ambiguous expression is mapped to the standardized business scenario label, the implicit priority inclination and resource preference in the unstructured field are quantified, and the implicit demand parameters are output.

[0056] The explicit demand parameters include resource type code, scale demand, and time sensitivity, and the implicit demand parameters include business type label, enterprise credit level, and historical task preference.

[0057] It should be noted that the resource type code refers to the hardware or service type identifier 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] Scale requirement refers to the quantitative indicators of resources explicitly required by users, such as computing resources (CPU core number (e.g. 16 cores), GPU card number (e.g. 4 cards)), memory capacity (64 GB DDR4), and storage space (1 TB NVMe SSD);

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

[0060] Business type label refers to the automatic classification of task scenarios through semantic analysis, such as AI training (requiring multi-GPU collaboration), stream data processing (requiring high-throughput network), and cold storage backup (requiring high-capacity HDD);

[0061] Enterprise credit rating refers to the dynamic credit score based on historical behavior evaluation, such as high-credit enterprises (can be overdrawn by 20% of resource quota), medium-credit enterprises (need to pre-authorize resources), and low-credit enterprises (only allocate 50% of the requested resources);

[0062] Historical task preference refers to the implicit resource allocation tendency in users' past tasks, such as regional preference, time period preference, and software stack preference.

[0063] The explicit requirement parameters and implicit requirement parameters are input into the requirement verification engine to perform multi-dimensional cross-verification to generate a standardized requirement description object.

[0064] Specifically, when the explicit requirement parameters and implicit requirement parameters are input into the requirement verification engine, a multi-dimensional cross-verification framework is constructed based on a logical rule engine and a graph neural network;

[0065] The structured fields of explicit parameters are parsed through syntax trees to check the format compliance and physical feasibility of resource types and scale requirements. Time sequence features are aligned to match the periodicity of explicit time sensitivity and implicit task preference. The time window weight of resource requirements is dynamically corrected. Tensor fusion technology is used to encode the verified parameters into a standardized requirement description object with a hypercube structure.

[0066] S2, real-time acquisition of cluster state data and external environment parameters, construction of user-task-environment three-dimensional feature tensor, output of standardized feature vector group.

[0067] Further, the probe deployed on the cluster node is used to acquire cluster state data in real time, and the external environment sensor network is accessed synchronously to obtain external environment parameters, generating a heterogeneous data stream with a timestamp;

[0068] Specifically, the real-time underlying hardware resource state and task runtime indicators are captured by lightweight probes deployed on cluster nodes, while physical environment constraints are collected by accessing a distributed environment sensor network, and multi-source data clocks are aligned using a high-precision time synchronization protocol. External environment parameters are parsed from sensor raw messages through a TCP protocol stack and abnormal value filtering is performed. All data streams are buffered and prioritized through a unified message queue middleware. Time series data cleaning and format standardization based on a sliding window are performed to eliminate data jitter caused by differences in sampling frequency, and finally, heterogeneous data streams with strictly aligned timestamps and multi-modal feature fusion are generated.

[0069] The cluster state data includes hardware resource state, network topology state, task running state, container instance state, and dynamic scheduling indicators, and the external environment parameters include user demand parameters, task priority parameters, physical environment constraints, network environment parameters, and policy control parameters.

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

[0071] The network topology state refers to the connection relationship and communication performance between cluster nodes, including connection topology (mapping relationship of physical / logical links between nodes), transmission indicators, and routing strategies.

[0072] The task running state refers to the real-time monitoring of task execution characteristics, including life cycle stages (queued, scheduled, running, suspended), resource consumption, and runtime indicators.

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

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

[0075] The user demand parameters refer to user-specified task requirements, including hardware acceleration requirements, data locality requirements, and compliance constraints.

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

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

[0078] The network environment parameters refer to the influence of external network conditions on tasks, including cross-domain bandwidth, public network delay, and security policies (firewall rules, DDoS attack detection status).

[0079] Policy regulation parameters refer to control variables for dynamically adjusting behaviors, including weight coefficients (such as trade-off coefficients of resource utilization and task delay), elastic threshold (resource water level triggering automatic expansion and contraction (such as CPU>80% for 5 minutes)), and fallback strategy (degradation strategy when task scheduling fails).

[0080] The heterogeneous data stream is input into the space-time alignment engine, time synchronization of multi-source data is performed, and a joint feature data set after space-time alignment is output.

[0081] Specifically, when processing the heterogeneous data stream through the space-time alignment engine, a hierarchical time axis correction architecture is adopted, nanosecond-level clock alignment is performed on the multi-source data stream based on the precise time protocol-pulse synchronization mechanism, and the timestamp offset caused by hardware clock drift or network delay is eliminated; for the spatial dimension, the graph embedding technology is used to map the physical topology coordinates to the low-dimensional manifold space, the propagation delay compensation amount of the multi-hop transmission path is calculated by combining the network hop number between nodes, and the data stream after space-time compensation is reorganized into a joint feature data set with strictly synchronized timestamps and spatial position topology association through the tensor fusion layer.

[0082] It should be noted that the length of the transmission path is determined by measuring the network hop number between nodes, the basic delay of each hop is evaluated by combining historical statistics and real-time link state, the fluctuating delay amount caused by network congestion or device load in the path is dynamically superimposed, the spatial modeling of the cross-node transmission path is performed based on the topological structure relationship, the implicit physical position association is captured by using the graph neural network, the cumulative error of the hop number model is automatically corrected, the delay compensation value matching the real transmission loss is generated, and the sub-millisecond-level synchronization accuracy of the heterogeneous data stream after space-time alignment is ensured.

[0083] The space-time alignment function is expressed as:

[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 reliability coefficient of the mth data source, α m ∈[0,1], D m represents the original numerical value of the mth data source, represents the integral from time t-τ to the current time point t, is expressed as the cumulative sum of the data source categories, and dξ is expressed as a historical time point variable.

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

[0088] Specifically, when separating multi-dimensional features from the joint feature dataset by tensor decomposition technology, a hybrid architecture combining orthogonal projection decomposition and multi-head attention mechanism is adopted, the global correlation structure of the joint feature data is analyzed, the matrix decomposition technology is used to decouple the mixed feature space into three groups of orthogonal vector spaces that do not interfere with each other, the core directional differences of user behavior patterns, task attribute features and environment state changes are identified based on data covariance relationship, and the orthogonal basis is constructed through feature vector projection; the adaptive gating mechanism is used to extract dimension-specific information flow along different basis directions, and the dynamic evolution law of each dimension feature is captured by combining time series modeling, and finally the user, task and environment independent and semantically interpretable vector representation space is formed; the unique feature components of each dimension are separated by using the gated residual network, and the separated user, task and environment features are input into the bidirectional LSTM time series encoder, the context semantic information is aggregated along the time axis and the low-rank representation is generated, the dimension difference is eliminated through the dynamic weight normalization layer, and three independent and orthogonal high-dimensional vector groups of user feature vectors, task feature vectors and environment feature vectors are formed.

[0089] It should be noted that in the unique feature component determination, the feature component attribution recognition is realized through multi-dimensional correlation analysis and semantic decoupling mechanism, the correlation strength of the feature and the user identity, task label and environment index is quantified by using mutual information, and the high contribution factor significantly related to a single dimension is selected; the cross-dimensional coupling interference components are inhibited by the gating mechanism combined with orthogonal projection, and the features that only have strong explanatory power in a specific context (such as user historical behavior sequence, task resource demand pattern or environment physical state) are retained; based on sparsity constraint and semantic interpretable verification, it is ensured that the separated user, task and environment features only reflect the core characteristics of a single dimension in statistical distribution and business logic.

[0090] The user feature vector is expressed as:

[0091]

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

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

[0094] The task feature vector is expressed as:

[0095]

[0096] In the formula, J represents the task feature vector, ρ represents the proportion of matrix operation instructions in the task, ρ∈[0,1], f represents the number of conditional jump instructions executed per unit time, L represents the spatial locality of memory access, L∈[0,1], η represents the degree of dispersion of non-continuous memory access, η∈[0,1], γ represents the zero constant prevention, γ=0.1, E” represents the estimated calculation energy consumption, E' represents the measured memory access energy consumption, and log(1+f) represents a 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 calculation energy consumption is the task calculation energy consumption predicted based on an instruction-level simulator; and the measured memory access energy consumption is measured in real time through a PMC counter.

[0098] The environmental feature vector is expressed as:

[0099]

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

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

[0102] Dynamic interaction fusion is performed, nonlinear fusion calculation is executed, a user-task-environment three-dimensional feature tensor is constructed, slice normalization processing is performed, and a standardized feature vector group is output.

[0103] Specifically, based on the cross attention calculation among the user, task, and environment feature vectors, a dimension-related weight matrix is generated to capture the potential coupling relationship between the user behavior pattern and the task resource demand, and the dynamic influence of the environmental constraints on the task feasibility is modeled;

[0104] The effective feature components of cross-dimension interaction are filtered through the gating mechanism to suppress noise interference and retain high-order nonlinear correlations; the fused user, task, and environment features are expanded into a three-dimensional tensor structure along the user, task, and environment axes through residual connection and layer normalization operation, wherein each slice corresponds to the interaction state of a specific dimension; slice-level normalization domains are divided according to user groups, task types, and environment scenarios for the three-dimensional tensor to eliminate distribution deviation between different slices, and a standardized feature vector group is output.

[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 environment state vector, β represents the time decay factor, β = 0.05, n represents the environment dimension index, W n represents the dynamic weight matrix of the nth environment dimension, W n ∈ [-1, 1], Φ(U n ,E n ) represents the Gaussian kernel matching function, N" represents the dimension number of the environment state vector, U n represents the mapping value of the user feature vector U in the nth environment dimension, E n represents the real-time observation value of the nth environment dimension of the environment state vector E, KL(P∥Q) represents the KL divergence of 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] A user-task-environment three-dimensional feature tensor is constructed, and the expression is:

[0109]

[0110] In the formula, F represents a 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 environment dimensions.

[0111] Preferably, by collecting cluster node probe data and external environment sensor network parameters in real time, a user-task-environment three-dimensional feature tensor is constructed to realize high-precision spatio-temporal alignment and dynamic interaction fusion of multi-source heterogeneous data. Deploy lightweight probes based on event-driven architecture to capture hardware resource status and task runtime indicators, synchronously integrate physical environment constraints and network topology parameters, use hierarchical time axis correction and improved dynamic time warping algorithm to eliminate time sequence 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 timestamped priority task queue.

[0113] Further, the standardized feature vector group is input into a hierarchical attention allocation mechanism, a two-dimensional attention weight matrix is calculated through a user-task interaction layer and a task-environment adaptation layer, and the fusion attention weight is output;

[0114] Specifically, when the standardized feature vector group is processed by the hierarchical attention allocation mechanism, a double-branch parallel processing architecture is used, 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 historical behavior pattern and the task resource demand;

[0115] The task-environment adaptation layer analyzes the compatibility weight of the task feature vector and the environment feature vector through the gated attention network, and quantifies the dynamic adaptability of task execution to physical constraint conditions. The attention weight matrix output by the double-branch is subjected to Hadamard product operation to generate a joint attention graph, and then a sparse gating unit is used to filter low-confidence interaction nodes, and the strong correlation attention connection among the user-task-environment is retained, and the residual connection and layer normalization operation are used to fuse into a unified attention weight matrix.

[0116] The user-task interaction layer is expressed as:

[0117]

[0118] In the formula, A represents the user-task interaction layer, Q u represents the user query matrix, K tdenotes the task-key matrix, d denotes the scaling factor, W q denotes the weight matrix of the trainable query space q, q denotes the query space, W k denotes 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 (dimension 0) of the input three-dimensional interaction feature tensor F through the weight matrix W q transformation; the task-key matrix is obtained by slicing the task dimension (dimension 1) of the input three-dimensional interaction feature tensor F through the weight matrix W k transformation; the scaling factor takes the dimension of the query / key vector (such as d = 64), which prevents gradient explosion caused by too large dot product, W q The user feature vector is mapped to the query space, which is used to represent the active demand characteristics of the user for the task. W. k The task feature vector is mapped to the key space, which is used to represent the passive requirement characteristics of the task for the resource.

[0120] Task-environment adaptation layer, 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 denotes the jth dimension feature of the environment state vector.

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

[0124] The fusion attention weight and the cluster state data are input into the reinforcement learning model for pre-training, dynamic score calculation is performed, and a priority score value is output;

[0125] Specifically, when the reinforcement learning model performs dynamic score calculation on the fusion of attention weight and cluster state data, the attention weight and real-time cluster state data are received by the policy network, the historical attention weight and cluster state data are modeled by the gated recurrent unit (GRU) to capture the periodicity of task scheduling requests and the timing correlation of resource release; the environment state encoder maps physical indicators such as real-time node load and network topology into low-dimensional semantic vectors to represent the dynamic running situation of the cluster; after cross-modal fusion, the policy network generates a probability distribution of candidate actions, such as preferentially scheduling to a low-load node or delaying task execution, and finally combines Monte Carlo tree search to weight sample high-return paths, realizing dynamic decision-making jointly driven by timing dependence and spatial state; in the dynamic scoring stage, the state transition probability is adjusted according to the attention weight, Monte Carlo tree search is used to explore high-value action paths, and a standardized priority score value is output.

[0126] The attention fusion is expressed as:

[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 contribution of user-task interaction and task-environment adaptation; the adjustment factor is used to control the influence strength of KL divergence on ω.

[0131] The dynamic priority score function is expressed as:

[0132]

[0133] In the formula, S'(t) represents the priority score value, τ represents the historical time, A”(τ) represents the attention weight at historical time τ, A”(τ)∈[0,1], Φ(F(τ)) represents the feature mapping function, F(τ) represents the three-dimensional interaction feature tensor at historical time τ, ρ'(τ) 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 k' of task type k', the gradient of parameter θ', ReLU represents the rectified function, Var(F k' ) represents the feature tensor variance of task type k'.

[0134] The priority score value is subjected to conflict resolution calculation to generate a priority score sequence without time overlap;

[0135] Specifically, the overlapping regions of the task time windows are quickly detected through the interval tree structure to identify the task pairs with resource competition conflicts; for the overlapping tasks, the weight coefficients of the conflict edges are dynamically calculated in combination with the resource demand similarity (such as strong competition among GPU-intensive tasks) and the real-time supply state of the cluster (such as the amount of remaining resources and the node load), and a conflict matrix reflecting multi-dimensional competition intensity is constructed; the maximum weight independent set is searched in the conflict graph by using the dynamic programming algorithm, the high-score tasks are preferentially retained and the low-priority conflict nodes are removed, and at the same time, the time offset of the remaining tasks is adjusted through the time window sliding strategy to ensure that the task execution intervals on the global time axis do not overlap with each other; the Hungarian algorithm is applied to optimize the bipartite graph matching of the tasks and the resources to generate a task sequence strictly meeting the time non-overlapping, resource mutual exclusivity and priority order.

[0136] The priority score sequence is arranged in descending order of the score values, and a nanosecond-level timestamp is injected to generate a priority task queue with a timestamp.

[0137] Specifically, after the priority score sequence is arranged in descending order by using a global sorting algorithm, a nanosecond-level timestamp is injected to each task node based on an atomic clock synchronization protocol, and a priority task queue with a timestamp is constructed through a time wheel data structure.

[0138] S4, according to the priority task queue, scanning the cluster resource topology structure, performing resource allocation and microsecond-level reorganization operation on the remaining resource fragments, outputting a resource allocation atlas, creating a container instance group with hardware acceleration constraints through a container orchestration engine, and injecting a real-time performance monitoring probe.

[0139] Further, the resource demand in the priority task queue is analyzed, and a three-dimensional resource topology tensor is constructed in combination with real-time cluster state data;

[0140] Specifically, the structured resource demand description is extracted from the task queue, including the core indicators such as the type of computing unit, the storage capacity and the network bandwidth; the three dimensions of the three-dimensional tensor are respectively mapped to the physical node topology structure, the resource category division and the dynamic performance indicator set, the task demand and the node resource state are spatially aligned through the tensor slicing operation, and a high-dimensional dense tensor is generated.

[0141] Based on the three-dimensional resource topology tensor, the matching degree of the remaining resource fragments and the tasks to be allocated is calculated through a fragment integration target function;

[0142] Specifically, the geometric distribution characteristics of the fragment block are extracted by tensor slicing, a dynamic convolution kernel is used to slide along the resource category dimension, the compatibility score of the fragment block under multi-dimensional constraints is calculated, and the KL divergence is used to measure the difference between the fragment distribution and the statistical characteristics of the task demand.

[0143] The fragment integration target function is expressed as:

[0144]

[0145] In the formula, G represents the fragment integration target function value, 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 resource allocation change, ρ" represents the load fluctuation rate, ρ" ∈ (0, 1), Δt represents the time interval, μ' represents the distribution matching coefficient, μ' = 0.7.

[0146] It should be noted that the resource allocation strategy matrix refers to the to-be-optimized variable, and the dimension is (resource type number x time step); the projection matrix of the fragment has a dimension of (resource type number x feature dimension), which maps the resource allocation to the task demand space; the expected target value of the fragment is generated by a task demand prediction model; the smoothing coefficient controls the punishment intensity of resource allocation change; the load fluctuation rate is calculated as the standard deviation of node utilization.

[0147] The fragment integration target function is converted into a quadratic unconstrained binary optimization form, and a quantum annealing machine is used to solve the preliminary integration, perform atomized resource reorganization operation, and output the resource allocation atlas.

[0148] Specifically, the resource block allocation decision is abstracted as a binary variable, and the multi-dimensional constraint is encoded into a quadratic term coefficient matrix through Hamiltonian construction; the quadratic unconstrained binary optimization form is embedded into the quantum annealing machine framework, and the quantum tunneling effect is used to break through the local optimal solution limit; after solving, based on the distributed transaction protocol, the matching resource block is executed for atomized reorganization operation, and through two-phase commit (2PC), the strong consistency of cross-node resource lock is ensured, the partial commit risk in the allocation process is eliminated, and the multi-dimensional resource allocation atlas is generated according to the quantum annealing result.

[0149] According to the resource allocation atlas, the accelerator type and resource quota are marked out, and a container configuration description file with hardware acceleration constraints is generated;

[0150] Specifically, the accelerator model and its resource quota marked in the parsing atlas are mapped to the hardware constraint label supported by the container orchestration engine, the NUMA affinity strategy is generated according to the topology coordinates, and the exclusive binding of the container to the CPU core group, the memory node and the physical position of the accelerator is declared; by embedding the accelerator driver version and microcode loading instruction in the annotation field, it is ensured that the compatible kernel and firmware are automatically mounted when the container instance is started, and the generated configuration description file is generated.

[0151] The node selector of the container orchestration engine is called, the container configuration description file is accurately matched with the physical topology label of the cluster node, and the container instance group is created on the target node group;

[0152] Specifically, by the hardware topology label marked in the resource allocation atlas, the topology constraint condition is declared in the container configuration description file, the scheduler is driven to traverse the metadata label library of the cluster node to perform accurate matching, the container configuration requirement is mapped to the node label in multiple levels, and for the scene with multiple target conflicts, the optimal node group is solved by the Hungarian algorithm; after successful matching, the scheduler reserves the target resource based on the real-time load state of the node group, and calls the atomic deployment interface of the orchestration engine to create a container instance group on the target node group.

[0153] Real-time performance monitoring probes are injected into the container instance group through a kernel bypass method.

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

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

[0156] Further, the heterogeneous performance data stream collected by the real-time performance monitoring probe is spatiotemporally aligned and normalized, and after filling in the missing values, a multi-modal time series feature matrix is generated.

[0157] Specifically, the timestamps of each data source are aligned by a high-precision clock synchronization protocol, the dynamic time warping algorithm is used to compensate for the sampling frequency difference, and the timing misalignment caused by cross-device clock drift is eliminated; then the dimension difference is eliminated by Z-score standardization and quantile normalization, and the data void is filled by spatiotemporal Kriging interpolation; the processed data stream is input into a multi-head self-attention encoder to extract the potential association pattern between cross-modal features, and a dense feature matrix representing time points and multi-dimensional indicators (such as GPU SM utilization, RDMA retransmission rate, cache consistency events) is constructed.

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

[0159] Specifically, the multi-modal time series feature matrix is divided into continuous subsequences according to the time sliding window, the long and short term dependence relationship is captured by stacking LSTM layers, and the time series contribution degree of different modal features is dynamically weighted by using the multi-head self-attention module, the output layer integrates the Bayesian inference framework, and multiple sets of prediction results are generated by Monte Carlo Dropout sampling, and the Bootstrap resampling technique is used to calculate the median value and confidence interval boundary of the resource demand of each container group in the future time domain.

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

[0161] It should be noted that the preset dynamic KL divergence threshold is calculated according to the historical cluster state data to statistically characterize the resource distribution under normal load, the statistical distribution of the KL divergence is calculated, and the high percentile value is taken as the initial reference; the sensitivity of the KL divergence threshold is dynamically adjusted combined with the feedback of real-time monitoring of abnormal events (such as false positive rate, missed detection rate), and the dynamic KL divergence threshold is weighted and corrected according to the business priority (such as the SLA requirement of critical tasks), and finally the effectiveness of the dynamic KL divergence threshold is verified by stress testing of simulated extreme scenarios, forming a dynamic judgment standard that takes into account stability and adaptability.

[0162] Specifically, a plurality of resource allocation scenarios are randomly generated by a probability distribution of resource demand prediction, and a joint distribution of resource state in each scenario is calculated in combination with a Bayesian inference framework; current cluster resource utilization, task queue load and hardware health indicators are collected in real time, and the deviation degree from the predicted distribution is quantified by KL divergence. If the dynamic KL divergence threshold is broken, the abnormality detection engine is triggered, the time window of the abnormal task is located through time series pattern matching, and the impact range is determined in combination with resource topology dependency analysis; atomic resource recovery and reallocation are performed, and migration to nodes with low fragmentation and high hardware compatibility is prioritized, while traffic shaping strategies are injected to smooth the transition.

[0163] Checkpoint snapshots of the container are migrated to the topology-matched node through a secure encrypted channel, and a scheduling performance report is generated by log analysis.

[0164] Specifically, an end-to-end encrypted tunnel is established through a quantum key distribution protocol, and the node identity is verified in combination with a hardware root of trust to ensure the confidentiality and integrity of the snapshot data; after incremental compression and differential encoding, the snapshot data is selected to the target node with the nearest physical location and matching hardware configuration according to the topology label of the resource allocation graph, and is transmitted at a microsecond level through RDMA zero-copy technology. After migration, the distributed log collector aggregates the full-link operation logs, inputs the stream processing engine for multi-dimensional correlation analysis, and generates a visual performance report containing resource utilization prediction, task restart success rate and hardware failure heat map.

[0165] The heterogeneous performance data stream includes GPU memory bandwidth, TPU matrix computation unit utilization, and RDMA network delay indicators.

[0166] It should be noted that the GPU memory bandwidth refers to the maximum rate of data exchange between the memory controller and the GPU computing core per unit time, which is determined by the memory type, bit width and frequency.

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

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

[0169] The embodiment also provides a computer device suitable for the computing resource scheduling method based on user demand and task priority, which comprises 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 realize the computing resource scheduling method based on user demand and task priority as proposed in the above embodiment.

[0170] The computer device can be a terminal, and the computer device includes a processor, a memory, a communication interface, a display screen and an input device connected by a system bus. The processor of the computer device is configured 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 a computer program. The internal memory provides an environment for running the operating system and the computer program in the non-volatile storage medium. The communication interface of the computer device is configured to perform wired or wireless communication with an external terminal. The wireless communication can be achieved by WIFI, a carrier network, 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 overlaid on the display screen, or a key, a trackball or a touchpad arranged on the shell of the computer device, or an external keyboard, a touchpad or a mouse, etc.

[0171] The embodiment also provides a storage medium having a computer program stored thereon, and the computer program is executed by a processor to implement the method for scheduling computing resources based on user's demand and task priority as described 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 a static random access memory (SRAM), an electrically erasable programmable read-only memory (EEPROM), an erasable programmable read-only memory (EPROM), a programmable read-only memory (PROM), a read-only memory (ROM), a magnetic memory, a flash memory, a magnetic disk or an optical disk.

[0172] To sum up, the application realizes the space alignment of multi-dimensional features and the fusion of time sequence cumulative effect by constructing a user-task-environment three-dimensional feature tensor and combining a reinforcement learning model to generate a dynamic hybrid weighted priority score. Based on the collaborative coding of standardized demand description objects and real-time cluster state data, the matching degree of hardware acceleration resource demand and supply can be accurately quantified, and the continuous allocation probability of FPGA / GPU memory blocks can be improved through a microsecond-level resource fragment reorganization algorithm. The pre-trained LSTM elastic scaling decision model analyzes the performance data stream of the container instance group, dynamically solves the resource topology constraint boundary condition, and realizes the active prediction and hot migration of abnormal tasks. The container instance group creation mechanism with hardware acceleration constraints ensures that compute-intensive tasks can be directly bound to physical devices with optimal NUMA affinity, and the injected real-time performance monitoring probe captures the bottom-layer hardware state transition events, providing millisecond-level response autonomous decision-making capability for large-scale heterogeneous computing clusters.

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

Claims

1. A computing resource scheduling method based on user needs and task priorities, characterized in that: include, Receive computing task requests submitted by users, parse and verify explicit and implicit requirement parameters, and generate standardized requirement description objects; Real-time acquisition of cluster status data and external environment parameters; construction of a three-dimensional feature tensor of user-task-environment; and output of a standardized feature vector set. The standardized feature vector set is input into the pre-trained reinforcement learning model to calculate the dynamically mixed weighted priority score and generate a priority task queue with timestamps. Based on the priority task queue, the cluster resource topology is scanned, and resource allocation and microsecond-level reassembly operations are performed on the remaining resource fragments, outputting a resource allocation graph. The specific steps are as follows. Analyze the resource requirements in the priority task queue and construct a three-dimensional resource topology tensor by combining real-time cluster status data; Based on the three-dimensional resource topology tensor, the matching degree between the remaining resource fragments and the tasks to be assigned is calculated through the fragment integration objective function; The fragment integration objective function is transformed into a quadratic unconstrained binary optimization form. The initial integration is solved using a quantum annealing machine. Atomized resource recombination operation is performed, and a resource allocation map is output. The specific steps are as follows: Create a group of container instances with hardware acceleration constraints using a container orchestration engine and inject real-time performance monitoring probes. Based on the resource allocation map, the accelerator types and resource quotas are marked, and a container configuration description file with hardware acceleration constraints is generated. The node selector of the container orchestration engine is invoked to precisely match the container configuration description file with the physical topology labels of the cluster nodes, and a group of container instances is created on the target node group. Inject real-time performance monitoring probes into container instance groups using a kernel bypass method; The system collects performance data streams from container instance groups, triggers elastic scaling decisions based on a pre-trained LSTM prediction model, dynamically adjusts cluster resource configuration, and reschedules abnormal tasks. The specific steps are as follows: Spatiotemporal alignment and normalization are performed on the heterogeneous performance data streams collected by the real-time performance monitoring probe. After filling in the missing values, a multimodal time series feature matrix is ​​generated. The multimodal 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 outputs the demand prediction value with confidence interval. The elastic scaling instruction set is generated by sampling the Monte Carlo scene, and the KL divergence between the current resource status and the predicted value is calculated in real time. If it exceeds the preset dynamic KL divergence threshold, the abnormal task is rescheduled. Container checkpoint snapshots are migrated to topology matching nodes via a secure encrypted channel, and log analysis is performed to generate scheduling performance reports.

2. The computing resource scheduling method based on user needs and task priorities according to claim 1, characterized in that: The specific steps for receiving user-submitted computation task requests, parsing and verifying explicit and implicit requirement parameters, and generating standardized requirement description objects are as follows: Receive raw computing task requests submitted by users through a declarative API interface and obtain explicit requirement parameters; A natural language processor is used to parse the unstructured description fields in the original computing task request and extract implicit requirement parameters; Explicit and implicit requirement parameters are input into the requirement verification engine to perform multi-dimensional cross-validation and generate standardized requirement description objects.

3. The computing resource scheduling method based on user needs and task priorities according to claim 2, characterized in that: The process of acquiring real-time cluster status data and external environment parameters, constructing a user-task-environment three-dimensional feature tensor, and outputting a standardized feature vector set involves the following steps: By deploying probes on cluster nodes to acquire cluster status data in real time, and synchronously accessing the external environment sensor network to acquire external environment parameters, a heterogeneous data stream with timestamps is generated. The heterogeneous data stream is input into the spatiotemporal alignment engine to perform time synchronization of multi-source data and output a spatiotemporally aligned joint feature dataset. Separate user-dimensional features, task-dimensional features, and environment-dimensional features from the joint feature dataset, and construct user feature vectors, task feature vectors, and environment feature vectors respectively; Dynamic interactive fusion is performed, nonlinear fusion calculation is executed, a three-dimensional feature tensor of user-task-environment is constructed, slice normalization processing is performed, and a standardized feature vector group is output.

4. The computing resource scheduling method based on user needs and task priorities according to claim 3, characterized in that: The steps for inputting standardized feature vector sets into a pre-trained reinforcement learning model, calculating dynamically weighted priority scores, and generating a priority task queue with timestamps are as follows. The standardized feature vector group is input into the hierarchical attention allocation mechanism, and a two-dimensional attention weight matrix is ​​calculated through the user-task interaction layer and the task-environment adaptation layer to output the fused attention weight. The attention weights and cluster state data are fed into the reinforcement learning model for pre-training, dynamic scoring is performed, and priority score values ​​are output. Conflict resolution calculations are performed on the priority scores to generate a priority score sequence without temporal overlap; The priority score sequence is sorted in descending order of score value, and a nanosecond-level timestamp is injected to generate a priority task queue with timestamps.

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

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

7. 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 5.

Images