Resource scheduling method and device, network equipment, storage medium and program product

Abstract

The invention discloses a resource scheduling method and device, network equipment, a storage medium and a program product, and relates to the technical field of resource scheduling. The method comprises the following steps: receiving a computing power request of a first node; obtaining state parameters of the candidate nodes; and determining a node corresponding to each to-be-processed task in the candidate nodes according to the computing power request and the state parameters of the candidate nodes. Determining a resource demand, a task type and a time delay requirement of a to-be-processed task of the first node by analyzing the computing power request, and determining the to-be-processed task of the first node according to a state parameter of the candidate node comprising at least one of a load, a residual computing power and a historical task success rate of the candidate node and delay data between the first node and the candidate node; and determining the node corresponding to the to-be-processed task in the candidate nodes, thereby selecting the corresponding node to process the task according to the resource demand, the task type and the time delay demand of the to-be-processed task, and maximizing the resource utilization of the node under the condition of ensuring the processing time delay.

Description

Technical Field

[0001] This application relates to the field of mobile resource scheduling, specifically to a resource scheduling method, apparatus, network equipment, storage medium, and program product. Background Technology

[0002] In existing cloud resource scheduling methods, after receiving computing power requests from various virtual scenario nodes, the cloud management platform simply allocates tasks to available server nodes. Resource allocation is often based on a first-come, first-served principle, lacking optimization for complex cloud computing scenarios. It does not consider factors such as task priority, the diversity of resource requirements, and latency constraints, which can lead to delays for high-priority tasks due to resources being occupied by low-priority tasks.

[0003] As the number of tasks such as real-time interaction and high-definition rendering increases for telecom operators, existing resource scheduling technologies lack optimization strategies for these tasks and cannot maximize resource utilization while ensuring low latency, thus failing to meet telecom operators' demands for high service quality and user experience. Summary of the Invention

[0004] At least one embodiment of this application provides a resource scheduling method, apparatus, network device, storage medium, and program product to solve the problem that existing cloud resource scheduling methods cannot maximize resource utilization while ensuring low latency.

[0005] To solve the above-mentioned technical problems, this application is implemented as follows:

[0006] In a first aspect, embodiments of this application provide a resource scheduling method applied to a first server, comprising:

[0007] Receive computing power requests from the first node; the computing power requests include the resource requirements, task types, and latency requirements of multiple tasks to be processed;

[0008] Obtain the status parameters of the candidate node; the status parameters include at least one of the following: the load, remaining computing power, historical task success rate, and latency data between the first node and the candidate node of the candidate node;

[0009] The node corresponding to each task to be processed among the candidate nodes is determined based on the computing power request and the status parameters of the candidate nodes.

[0010] Optionally, determining the node corresponding to each task to be processed among the candidate nodes based on the computing power request and the status parameters of the candidate nodes includes:

[0011] The candidate node set is determined based on the load of the candidate nodes;

[0012] The nodes in the candidate node set are sorted by priority to obtain a node sequence; the priority is determined based on at least one of the remaining computing power, historical task success rate, and latency data between the first node and the candidate nodes.

[0013] Based on the computing power request and the node sequence, determine the node corresponding to each of the candidate nodes for the task to be processed.

[0014] Optionally, based on the computing power request and the node sequence, the node corresponding to each task to be processed is determined, including:

[0015] If the latency requirement of the first task in the pending tasks is less than the first preset latency, determine the first target node in the node sequence corresponding to the first task;

[0016] The first target node is the node with the smallest delay data in the node sequence.

[0017] Optionally, the method further includes:

[0018] The same task to be processed is processed simultaneously on multiple first target nodes;

[0019] Upon receiving the processing result for the task to be processed, stop all processing of the task to be processed by the first target nodes.

[0020] Optionally, based on the computing power request and the node sequence, the node corresponding to each task to be processed is determined, including:

[0021] If the resource requirements of the task to be processed exceed a preset threshold, the task to be processed will be split into multiple sub-tasks.

[0022] Identify multiple second target nodes in the node sequence; the second target nodes are nodes in the node sequence whose remaining computing power is greater than the resource requirements of the subtask.

[0023] Based on the resource weight, demand deviation rate, deviation weight of each subtask, and the remaining computing power of the second target node, the second target node corresponding to each subtask is determined.

[0024] Optionally, based on the resource weight, demand deviation rate, deviation weight of each subtask, and the remaining computing power of the second target node, the second target node corresponding to each subtask is determined, including:

[0025] Determine the matching degree between each subtask and the second target node;

[0026] The second target node corresponding to each subtask is determined based on the matching degree;

[0027] Wherein, the matching degree = (remaining computing power × resource weight) + (1 - demand deviation rate × deviation weight);

[0028] The resource weight is determined based on the type of the subtask;

[0029] Demand deviation rate = |Remaining computing power - Resource requirements of subtasks| / Resource requirements of subtasks;

[0030] The deviation weight is inversely proportional to the demand deviation rate.

[0031] Optionally, the method further includes:

[0032] If no node matching the first subtask is found in the second target node, the node sequence is checked at preset intervals to determine the third target node corresponding to the first subtask; or,

[0033] If no matching node for the first subtask is found in the second target node after a preset time threshold, the target resource for the target task in the fourth target node is released, and the first subtask is processed on the target resource in the fourth target node; the target task is a task with a lower priority than the first subtask, and the task priority is determined based on at least one of the task's resource requirements, task type, and latency requirements; the target resource is at least a portion of the resources used to process the target task.

[0034] Optionally, the method further includes:

[0035] If the number of the first target nodes is less than the number of the first tasks, the first tasks will be assigned to the first target nodes and the fifth target nodes.

[0036] The fifth target node is a node other than the candidate nodes. The remaining computing power of the fifth target node is greater than the resource requirements of the first task, and the latency data of the fifth target node is less than the latency requirements of the first task.

[0037] Optionally, assigning the first task to the first target node and the fifth target node includes:

[0038] Assign the second task from the first task to the fifth target node;

[0039] The second task is a task with a latency requirement of less than a second preset latency, and the second preset latency is less than the first preset latency.

[0040] Optionally, determining the node corresponding to each task to be processed based on the computing power request and the node sequence includes:

[0041] If the latency requirement of the third task in the pending tasks is greater than the third preset latency, and the nodes in the candidate node set are in an idle state, the computing power of the candidate nodes is allocated to the third task at a rate not greater than a preset proportion.

[0042] The third preset delay is greater than the first preset delay.

[0043] Secondly, embodiments of this application provide a resource scheduling method apparatus, comprising:

[0044] The receiving module is used to receive the computing power request from the first node; the computing power request includes the resource requirements, task types and latency requirements of multiple tasks to be processed;

[0045] The acquisition module is used to acquire the status parameters of the candidate node; the status parameters include at least one of the following: the load, remaining computing power, historical task success rate, and latency data between the first node and the candidate node of the candidate node;

[0046] The determination module is used to determine the node corresponding to each of the candidate nodes for the task to be processed based on the computing power request and the status parameters of the candidate nodes.

[0047] Thirdly, embodiments of this application provide a network device, including a transceiver and a processor, wherein...

[0048] The transceiver is used to receive computing power requests from the first node; the computing power requests include the resource requirements, task types, and latency requirements of multiple tasks to be processed.

[0049] Obtain the status parameters of the candidate node; the status parameters include at least one of the following: the load, remaining computing power, historical task success rate, and latency data between the first node and the candidate node of the candidate node;

[0050] The processor is configured to determine the node corresponding to each of the candidate nodes for the task to be processed based on the computing power request and the status parameters of the candidate nodes.

[0051] Fourthly, embodiments of this application provide a network device, including: a processor, a memory, and a program stored in the memory and executable on the processor, wherein the program, when executed by the processor, implements the steps of the method described in the first aspect.

[0052] Fifthly, embodiments of this application provide a computer-readable storage medium storing a program that, when executed by a processor, implements the steps of the method described above.

[0053] In a sixth aspect, embodiments of this application provide a computer program product including computer instructions that, when executed by a processor, implement the steps of the method described in the first aspect.

[0054] Compared with the prior art, the resource scheduling method, apparatus, network device, storage medium and program product provided in this application analyze the computing power request of the first node to determine the resource requirements, task type and latency requirements of the task to be processed of the first node. Then, based on the status parameters of the candidate nodes, including at least one of the candidate nodes' load, remaining computing power, historical task success rate and latency data between the first node and the candidate nodes, the node corresponding to the task to be processed is determined among the candidate nodes. Thus, according to the different resource requirements, task type and latency requirements of the task to be processed, the corresponding node is selected for task processing, which can maximize the resource utilization of the candidate nodes while ensuring the processing latency of the task to be processed. Attached Figure Description

[0055] Various other advantages and benefits will become apparent to those skilled in the art upon reading the following detailed description of preferred embodiments. The accompanying drawings are for illustrative purposes only and are not intended to limit the scope of this application. Furthermore, the same reference numerals denote the same parts throughout the drawings. In the drawings:

[0056] Figure 1 This is a schematic diagram illustrating the steps of the resource scheduling method according to an embodiment of this application;

[0057] Figure 2 This is a schematic diagram of the modules of the resource scheduling device according to an embodiment of this application;

[0058] Figure 3 This is a schematic diagram of the network device according to an embodiment of this application;

[0059] Figure 4 This is a schematic diagram of the structure of a network device according to another embodiment of this application. Detailed Implementation

[0060] Exemplary embodiments of the present application will now be described in more detail with reference to the accompanying drawings. While exemplary embodiments of the present application are shown in the drawings, it should be understood that the present application may be implemented in various forms and should not be limited to the embodiments set forth herein. Rather, these embodiments are provided so that this application will be thorough and complete, and will fully convey the scope of the present application to those skilled in the art.

[0061] The terms “first,” “second,” etc., used in the specification and claims of this application are used to distinguish similar objects and are not necessarily used to describe a specific order or sequence. It should be understood that such data can be interchanged where appropriate so that the embodiments of this application described herein can be implemented, for example, in orders other than those illustrated or described herein. Furthermore, the terms “comprising” and “having,” and any variations thereof, are intended to cover a non-exclusive inclusion; for example, a process, method, system, product, or apparatus that comprises a series of steps or units is not necessarily limited to those steps or units explicitly listed, but may include other steps or units not explicitly listed or inherent to such processes, methods, products, or apparatus. The terms “and / or” in the specification and claims indicate at least one of the connected objects.

[0062] The technologies described in this document are not limited to NR systems and Long Time Evolution (LTE) / LTE-Advanced (LTE-A) systems, but can also be used in various wireless communication systems such as Code Division Multiple Access (CDMA), Time Division Multiple Access (TDMA), Frequency Division Multiple Access (FDMA), Orthogonal Frequency Division Multiple Access (OFDMA), Single-carrier Frequency-Division Multiple Access (SC-FDMA), and other systems. The terms "system" and "network" are often used interchangeably. CDMA systems can implement radio technologies such as CDMA2000 and Universal Terrestrial Radio Access (UTRA). UTRA includes Wideband Code Division Multiple Access (WCDMA) and other CDMA variants. TDMA systems can implement radio technologies such as the Global System for Mobile Communication (GSM). OFDMA systems can implement radio technologies such as Ultra Mobile Broadband (UMB), Evolution-UTRA (E-UTRA), IEEE 802.21 (Wi-Fi), IEEE 802.16 (WiMAX), IEEE 802.20, and Flash-OFDM. UTRA and E-UTRA are parts of the Universal Mobile Telecommunications System (UMTS). LTE and more advanced LTE (such as LTE-A) are newer versions of UMTS that use E-UTRA. UTRA, E-UTRA, UMTS, LTE, LTE-A, and GSM are described in documents from an organization called the 3rd Generation Partnership Project (3GPP). CDMA2000 and UMB are described in documents from an organization called 3rd Generation Partnership Project 2 (3GPP2).The techniques described herein can be used with the systems and radio technologies mentioned above, as well as with other systems and radio technologies. However, the following description describes NR systems for illustrative purposes, and NR terminology is used in most of the following description, although these techniques can also be applied to applications beyond NR systems.

[0063] The following description provides examples and is not intended to limit the scope, applicability, or configuration set forth in the claims. Changes may be made to the function and arrangement of the elements discussed without departing from the spirit and scope of this disclosure. Various procedures or components may be appropriately omitted, substituted, or added to the examples. For example, the described methods may be performed in a different order than described, and various steps may be added, omitted, or combined. Furthermore, features described with reference to certain examples may be combined in other examples.

[0064] like Figure 1 As shown in the embodiment of this application, a resource scheduling method includes the following steps:

[0065] Step 101: Receive the computing power request from the first node; the computing power request includes the resource requirements, task types and latency requirements of multiple tasks to be processed;

[0066] Step 102: Obtain the status parameters of the candidate node; the status parameters include at least one of the following: the load, remaining computing power, historical task success rate, and latency data between the first node and the candidate node of the candidate node;

[0067] Step 103: Determine the node corresponding to each task to be processed among the candidate nodes based on the computing power request and the status parameters of the candidate nodes.

[0068] It should be noted that the first server in this application can be a cloud management platform. The first node is a node corresponding to each virtual scene, such as a user client, AI entity, dynamic environment simulator, etc.; the virtual scenes include real-time interactive scenes that are highly sensitive to latency (such as VR games, remote medical surgery guidance, etc.), GPU-intensive tasks that are less sensitive to latency (such as 3D rendering, AI inference), and CPU-intensive tasks (such as physics simulation, data processing), etc. All candidate nodes are edge nodes.

[0069] Optionally, receiving computing power requests from the first node includes:

[0070] After receiving the computing power request, the computing power request is parsed to obtain the corresponding tasks to be processed, as well as the priority, resource requirements and latency of each task.

[0071] For example, the priority of the tasks to be processed includes: categorization based on scene type (e.g., priority 1 for real-time interactive scenes and priority 2 for static rendering scenes). In practical applications, priorities are pre-set according to different scene types; for example, real-time interactive scenes (such as VR games, remote medical surgery guidance, etc.) are set to the highest priority due to their high sensitivity to latency, ensuring that these tasks receive the fastest resource response; while static rendering scenes (such as offline image rendering, data analysis, etc.) are set to the second priority because their real-time requirements are relatively low.

[0072] The resource scheduling method in this application can effectively guarantee the resource priority of critical tasks by classifying the tasks to be processed into task types.

[0073] For example, the resource requirements include: GPU computing power (TFLOPS), memory (GB), and network bandwidth (Gbps).

[0074] For example, the latency constraint refers to the maximum allowable latency that a virtual scene node must meet when performing a corresponding task (e.g., ≤50ms for real-time interactive tasks and ≤200ms for rendering tasks). For instance, when a virtual scene node undertakes a real-time interactive task (such as VR collaboration or remote control), its latency constraint must be strictly controlled within ≤50ms to ensure a smooth user experience; while when the node performs a rendering task (such as 3D model generation or video transcoding), the latency constraint can be relaxed to ≤200ms.

[0075] The resource scheduling method in this application classifies tasks with different latency constraints, which can clearly distinguish the different requirements of different task types for response speed, providing an accurate latency benchmark for resource scheduling and avoiding task execution failure or inefficiency due to latency mismatch.

[0076] For example, the task type directly corresponds to the specific computational work carried out by the virtual scene node, including: 3D rendering, physical simulation, AI inference, etc. For instance, in a virtual game scene, the user client, as a virtual scene node, may trigger a 3D rendering task to generate high-definition images; in an intelligent driving simulation system, the dynamic environment simulator node needs to perform a physical simulation task to reproduce real road conditions; while AI inference tasks are commonly found on edge nodes equipped with intelligent algorithms, used for real-time analysis of video streams or voice data.

[0077] The resource scheduling method in this application embodiment, by clearly defining the correlation between task type and node, allows the scheduling system to accurately match node hardware characteristics (such as GPU computing power) with task requirements, thereby avoiding resource mismatch.

[0078] The resource scheduling method provided in this application analyzes the computing power request of a first node to determine the resource requirements, task type, and latency requirements of the task to be processed on the first node. Then, based on the status parameters of the candidate nodes, including at least one of the following: load, remaining computing power, historical task success rate, and latency data between the first node and the candidate nodes, the method determines the node among the candidate nodes that corresponds to the task to be processed. Thus, according to the different resource requirements, task type, and latency requirements of the task to be processed, the method selects the corresponding node for task processing, thereby maximizing the resource utilization of the candidate nodes while ensuring the processing latency of the task to be processed.

[0079] Optionally, determining the node corresponding to each task to be processed among the candidate nodes based on the computing power request and the status parameters of the candidate nodes includes:

[0080] The candidate node set is determined based on the load of the candidate nodes;

[0081] The nodes in the candidate node set are sorted by priority to obtain a node sequence; the priority is determined based on at least one of the remaining computing power, historical task success rate, and latency data between the first node and the candidate nodes.

[0082] Based on the computing power request and the node sequence, determine the node corresponding to each of the candidate nodes for the task to be processed.

[0083] Optionally, the candidate node set is determined based on the load of the candidate nodes, including:

[0084] The nodes whose load is less than the preset load are identified as the candidate node set.

[0085] For example, nodes with a load of less than 85% are selected to form the candidate node set.

[0086] The resource scheduling method in this application avoids assigning tasks to high-load nodes by screening candidate nodes, ensuring system stability and task execution efficiency. This step dynamically evaluates the real-time load status of candidate nodes (such as CPU / GPU utilization and memory usage) and excludes nodes whose load exceeds a load threshold (such as 85%). These two steps form a progressive logic: first matching hardware capabilities, then verifying resource availability, thereby balancing task requirements and system stability.

[0087] Load threshold: Exclude nodes with a load > 85%. The load threshold is a maximum resource usage limit set to ensure stable node operation. The system monitors the utilization of critical resources such as CPU, GPU, and memory on each node in real time. When the utilization of any resource exceeds the preset 85%, the node is determined to be in a high-load state and excluded from the current task allocation range to prevent performance degradation.

[0088] Optionally, the load of the node is calculated based on a combination of CPU / GPU utilization, memory usage, and task queue length.

[0089] For example, the load of the node is calculated using the following formula: Load = 0.5 CPU utilization + 0.3 GPU utilization + 0.2 memory usage.

[0090] Furthermore, after nodes are configured according to task type, the scheduling system (cloud management platform) continuously monitors the resource usage of these nodes in real time. At this point, CPU utilization, GPU utilization, and memory usage are dynamically collected by the node's own monitoring module and fed back to the scheduling system, providing known real-time data. The scheduling system substitutes these specific values ​​into the load calculation formula to calculate the overall load value of the current node, and then determines whether it exceeds the load threshold, in order to decide whether to exclude the node.

[0091] For example, the exclusion rules for nodes:

[0092] If a node load is >85%, it is marked as unavailable until the load drops below the load threshold.

[0093] Furthermore, when a node's load exceeds 85% and it is marked as unavailable, the scheduling system will take a series of measures to reduce its load. For example, on the one hand, it will suspend the allocation of new tasks to the node to prevent the load from increasing further; on the other hand, it will instruct the node to optimize its internal processes and clean up unnecessary caches and background tasks. Once the node's load falls below the threshold, the system will re-mark it as available and allow it to continue participating in task allocation.

[0094] Optionally, the cloud management platform dynamically monitors the load changes of each node and updates the node status every 10 seconds.

[0095] Specifically, to achieve dynamic monitoring of load changes, the system can collect resource data in real time by deploying lightweight monitoring agents on each node. For example, every 10 seconds, the agent requests real-time utilization information of CPU, GPU, and memory from the node's operating system and calculates the overall load value according to the load calculation formula. The calculation results are uploaded to the central scheduling server via an encrypted channel, and the server synchronously updates the node status database. If the load is detected to exceed 85%, a node unavailable flag is immediately triggered and a timestamp is recorded, thus forming a complete dynamic monitoring closed loop.

[0096] Example:

[0097] Node A: CPU utilization 90%, GPU utilization 80%, memory utilization 70% → Load = 0.5×90 + 0.3×80 + 0.2×70 = 83% (available, i.e., candidate node).

[0098] Node B: CPU utilization 95%, GPU utilization 85%, memory utilization 80% → Load = 0.5×95 + 0.3×85 + 0.2×80 = 90% (excluded from the candidate node set).

[0099] Optionally, the nodes in the candidate node set are sorted by priority to obtain a node sequence, including:

[0100] The nodes in the candidate node set are sorted by priority according to the remaining computing power, the latency data, and the historical task success rate.

[0101] For example, a three-level sorting rule is used to prioritize the nodes in the candidate node set;

[0102] The process is executed sequentially based on remaining computing power, latency data, and historical task success rates to ensure that resource allocation achieves an optimal balance between computing power, latency, and reliability.

[0103] Specifically, different tasks have varying requirements for computing power, latency, and reliability. For example, real-time interactive tasks are sensitive to latency, while critical data processing tasks prioritize reliability. The three-level sorting rule follows a hierarchical priority principle: first, it matches task requirements with computing power; then, it considers latency to meet real-time requirements; and finally, it ensures reliability to guarantee stable task execution. This sorting method selects the optimal node from available nodes, achieving an optimal balance between computing power, latency, and reliability in resource allocation, thereby improving overall scheduling efficiency.

[0104] First-level sorting: Nodes are sorted in descending order of remaining computing power (TFLOPS). The remaining computing power is not pre-set but dynamically calculated. The system first obtains the baseline computing power of the node hardware (e.g., 312 TFLOPS for an NVIDIA A100), then combines this with the GPU utilization obtained from real-time monitoring (e.g., currently at 70%), and calculates the actual available computing power using the formula "Remaining computing power = Baseline computing power × (1 - Current GPU utilization)". For example, an A100 node at 70% utilization has a remaining computing power of 312 × 0.3 = 93.6 TFLOPS. The nodes in the candidate node set are then sorted in descending order of this value, prioritizing the allocation of nodes with the most abundant computing power resources to ensure that tasks with high computing power demands receive sufficient performance support.

[0105] Secondary sorting: Nodes are sorted in ascending order based on network latency data (prioritizing edge nodes physically close to the requesting node). The system acquires network latency data between nodes and requesting nodes through multi-dimensional data to achieve secondary sorting. On one hand, it leverages global network measurement infrastructure (such as RIPE Atlas) to collect real-time network path latency data from each node to different regions. On the other hand, it continuously tests the round-trip time (RTT) from local nodes to requesting nodes using a distributed monitoring agent. Simultaneously, it analyzes the physical location of nodes using Geographic Information System (GIS) to prioritize edge nodes in the same or neighboring regions. Finally, all candidate nodes are sorted in ascending order of latency value to ensure tasks are assigned to nodes with close physical proximity and fast network transmission, reducing communication latency and improving the real-time interactive experience.

[0106] Three-level sorting: Sort by the historical task success rate of nodes (nodes with a success rate of ≥99% are given priority).

[0107] Specifically:

[0108] 1. First-level sorting: Sort in descending order by remaining computing power (TFLOPS) of nodes.

[0109] Objective: To prioritize the allocation of nodes with sufficient computing power to ensure efficient task completion.

[0110] Applicable Scenarios: When multiple server nodes can meet the basic computing power requirements, the node with the highest remaining computing power is selected first. The basic computing power requirement is determined by the task type and historical execution data. For example, image rendering tasks require at least 10 TFLOPS, and AI inference tasks require 5 TFLOPS. The system presets a minimum computing power threshold based on the task type. Simultaneously, it analyzes the average computing power consumption of the task's historical execution records and reserves 20% redundancy to form a dynamically adjusted basic requirement value. The remaining computing power is calculated as "total node computing power - currently occupied computing power," where the currently occupied computing power is converted in real-time by GPU utilization (e.g., 40% utilization corresponds to 124.8 TFLOPS). When the node's remaining computing power is greater than or equal to the task's basic requirement, it is considered to meet the condition and enters the sorting process.

[0111] Logic: Calculate the remaining computing power (currently available TFLOPS) of each server node, and then sort them from highest to lowest remaining computing power. For example:

[0112] Node A: 150 TFLOPS;

[0113] Node B: 120 TFLOPS;

[0114] Node C: 100 TFLOPS;

[0115] Sorting result: Node A > Node B > Node C.

[0116] Advantages: Maximizes the use of high-performance computing nodes, reducing task splitting and parallel overhead.

[0117] 2. Secondary sorting: Sort in ascending order by network latency.

[0118] Objective: To improve user experience by selecting the node with the lowest latency among nodes with comparable computing power. "Comparable computing power" can be clearly defined by quantifiable metrics: Using the highest remaining computing power among all nodes meeting basic computing power requirements as a benchmark, the remaining computing power of other nodes is compared to this benchmark. If the difference between a node's remaining computing power and the highest value is within 10% (e.g., if the highest remaining computing power is 100 TFLOPS, then nodes with a difference ≤10 TFLOPS are considered to have comparable computing power), these nodes are determined to be of the same priority in terms of computing power. Within this range, the system will no longer select based on computing power differences, but will instead switch to a secondary sorting rule, prioritizing the allocation of nodes with the lowest network latency, thereby optimizing user experience while maintaining balanced computing power.

[0119] Applicable scenarios: When there are multiple nodes with similar remaining computing power after the first-level sort (e.g., the difference is <10%).

[0120] Logic: Based on the first-level sorting results, select nodes with smaller remaining computing power differences (e.g., 10%).

[0121] These nodes are sorted from low to high network latency, for example:

[0122] Node A: Remaining computing power 150 TFLOPS, latency 30ms;

[0123] Node D: Remaining computing power 145 TFLOPS, latency 15ms;

[0124] The specific latency value here is not fixed and known, but is obtained through real-time monitoring. The system establishes a continuous network performance testing mechanism between the candidate node and the first node, using tools such as the Ping command, dedicated network probing tools, or distributed monitoring agents to periodically (e.g., every 5 seconds) send test data packets and record the round-trip time (RTT). At the same time, by combining network topology analysis and historical data, and eliminating the interference of instantaneous network fluctuations, a stable and reliable average latency value is calculated.

[0125] For example, the latency data of nodes A and D, after multiple tests and algorithm optimizations, are representative values ​​used as a key basis for secondary sorting when computing power is comparable, to ensure that the node with the lowest latency is selected.

[0126] Sorting result: Node D > Node A (although node A has slightly higher computing power, it has lower latency).

[0127] Advantages: Reduces response latency for real-time interactive tasks (e.g., VR operations require a latency of <50ms).

[0128] 3. Three-level sorting: Based on historical task success rate (nodes with ≥99% success rate are given priority).

[0129] Objective: Among nodes with similar computing power and latency, prioritize nodes with high reliability.

[0130] Applicable scenarios: When there are still multiple nodes with similar delays after secondary sorting (e.g., the difference is <5ms).

[0131] Logic: Based on the secondary sorting results, filter nodes with smaller network latency differences (e.g., 5ms).

[0132] These nodes are sorted from highest to lowest based on their historical task success rate (task success means that the node completes the calculation within the specified time, the output result is verified (such as data integrity and accuracy verification) and there are no abnormal interruptions or errors. The historical success rate is calculated as: the number of tasks successfully completed by the node in the last 30 days ÷ the total number of tasks × 100%, and nodes are sorted from highest to lowest according to this value). For example:

[0133] Node D: 15ms latency, 99.5% success rate;

[0134] Node E: 16ms latency, 98.8% success rate;

[0135] Sorting result: Node D > Node E.

[0136] Advantages: Reduces the risk of task failure and improves system stability.

[0137] Specifically, a comprehensive application example of three-level sorting:

[0138] Task to be processed: Real-time rendering of a high-precision 3D scene, requiring 100 TFLOPS of computing power, with a maximum allowable latency of 50ms.

[0139] Candidate nodes:

[0140] Node A: Remaining computing power 150 TFLOPS, latency 30ms, historical task success rate 98%;

[0141] Node B: Remaining computing power 120 TFLOPS, latency 15ms, historical task success rate 99.5%;

[0142] Node C: Remaining computing power 120 TFLOPS, latency 18ms, historical task success rate 99.8%;

[0143] Sorting process:

[0144] First-level sorting: descending order by remaining computing power:

[0145] Node A (150) > Node B (120) ≈ Node C (120);

[0146] Nodes B and C have the same computing power and proceed to the secondary sorting stage. If a multi-dimensional weighted sorting method is used, all candidate nodes (including nodes A, B, and C) must participate in a quantitative evaluation of dimensions such as computing power and latency. A comprehensive score is calculated through weighted calculations before ranking. In this case, even if node A has a higher computing power, it may still be surpassed by B or C if its latency or reliability weight score is lower. However, if a hierarchical sorting rule is used (first sorting by computing power in descending order, then by latency in ascending order if computing power is the same), node A, with the highest computing power, will directly win without needing to enter the secondary sorting stage. The two methods depend on the human design of the scheduling strategy; the former is suitable for balanced optimization, while the latter prioritizes efficiency.

[0147] Secondary sort: Ascending order by delay (in nodes B and C)

[0148] Node B (15ms) > Node C (18ms);

[0149] Node B has lower latency and is the preferred choice.

[0150] Three-level sorting: Triggered only when the latency difference between nodes B and C is extremely small (3ms in this example; assuming a threshold of 5ms, it will not trigger).

[0151] If the latency difference is less than 5ms and the computing power is the same, then sort by success rate.

[0152] Final allocation:

[0153] Node B (120 TFLOPS, 15ms, 99.5%) was selected because it provides the lowest latency given sufficient remaining computing power.

[0154] In this embodiment of the application, under the three-level ranking weight (computing power 0.8: latency 0.15: success rate 0.05), if the computing power of node A is significantly higher than that of B (e.g., 150 vs 120 TFLOPS), even if B has lower latency (15ms vs A's 20ms) and higher success rate (99.5% vs 99%), node A's overall score may still be higher (because computing power has a larger weighting).

[0155] However, if it is clear that "computing power is sufficient" (i.e., all nodes meet the basic requirements), then the weight of computing power is actually weakened, and the system pays more attention to latency and success rate. Because of the lowest latency (15ms) and extremely high success rate (99.5%), B scored outstandingly in the remaining dimensions, so its overall weight surpassed that of A, and it was ultimately selected.

[0156] Although node A has higher computing power, it has higher latency and a lower success rate, so it was not selected.

[0157] The applicable scenarios and effects are compared in Table 1:

[0158] Table 1

[0159] Scene type First-level ranking weight Secondary sorting weight Third-level sorting weight Typical applications Computation-intensive High (80%) Middle (15%) Low (5%) Offline rendering, AI model training Delay-sensitive Medium (50%) High (40%) Low (10%) VR interaction, real-time multiplayer collaboration High reliability China (60%) Middle (30%) High (10%) Financial simulation, medical simulation

[0160] Optionally, based on the computing power request and the node sequence, the node corresponding to each task to be processed is determined, including:

[0161] Based on the node sequence and the resource requirements, task types, and latency requirements of the tasks to be processed in the computing power request, the priority of each task to be processed is determined.

[0162] Based on the priority of the tasks to be processed and the node sequence, determine the node corresponding to each task to be processed.

[0163] Optionally, the priority of each task to be processed is determined based on the node sequence and the resource requirements, task type, and latency requirements of the tasks to be processed in the computing power request, including:

[0164] The task with the lowest latency requirement is identified as the highest priority task.

[0165] For example, real-time interactive tasks are identified as the highest priority tasks to be processed.

[0166] Optionally, based on the computing power request and the node sequence, the node corresponding to each task to be processed is determined, including:

[0167] If the latency requirement of the first task in the pending tasks is less than the first preset latency, determine the first target node in the node sequence corresponding to the first task;

[0168] The first target node is the node with the smallest delay data in the node sequence.

[0169] Optionally, the method further includes:

[0170] The same task to be processed is processed simultaneously on multiple first target nodes;

[0171] Upon receiving the processing result for the task to be processed, stop all processing of the task to be processed by the first target nodes.

[0172] For example, the latency requirement is less than the first preset latency for the task to be processed, such as a real-time interactive task.

[0173] For example, for a task to be processed where the latency requirement is less than a first preset latency, a node with a smaller latency is selected from the set of candidate nodes for task processing; and a redundancy allocation principle is adopted to ensure the processing speed of the task.

[0174] In one embodiment of this application, three nodes with the lowest latency are selected from the candidate node set, and tasks with latency requirements less than the first preset latency are processed simultaneously.

[0175] Specifically, the task to be processed is split into replicas with the same computational logic and sent in parallel to three selected low-latency nodes. Each node performs the computation independently and returns the result to the cloud management platform upon completion. The management platform monitors the response time in real time. Once it receives a valid result from any node (ensuring correctness through verification), it immediately terminates the computation tasks on other nodes (to avoid resource waste) and returns the result to the user. This approach trades space for time, leveraging the parallel processing of multiple nodes to improve task response speed, and is particularly suitable for latency-sensitive real-time interactive scenarios.

[0176] Furthermore, for the remaining computing power of each node, the monitoring module of the cloud management platform collects and reports data such as the current available computing power (total computing power minus the occupied part), memory and bandwidth in real time and periodically through the node's built-in resource manager (such as cAdvisor in Docker / Kubernetes) or a dedicated probe. The allocation amount is calculated according to the formula to ensure that the task requirements are met while reserving 20% ​​of the resources to prevent node overload and ensure the overall stability of the cluster.

[0177] Specifically, the allocation amount = min(resource requirements of the task to be processed, remaining computing power of the node × 0.8).

[0178] The resource scheduling method in this application embodiment can meet the response speed requirements of latency-sensitive tasks by prioritizing redundancy processing for such tasks.

[0179] Optionally, based on the computing power request and the node sequence, the node corresponding to each task to be processed is determined, including:

[0180] If the resource requirements of the task to be processed exceed a preset threshold, the task to be processed will be split into multiple sub-tasks.

[0181] Identify multiple second target nodes in the node sequence; the second target nodes are nodes in the node sequence whose remaining computing power is greater than the resource requirements of the subtask.

[0182] Based on the resource weight, demand deviation rate, deviation weight of each subtask, and the remaining computing power of the second target node, the second target node corresponding to each subtask is determined.

[0183] For tasks with high resource requirements, the computing power of a single node is often insufficient to meet the resource demands. Therefore, the task to be processed is split into multiple subtasks and processed in parallel on multiple nodes.

[0184] For example, in order to prevent subtasks from being fragmented, nodes with remaining computing power resources greater than 1.2 times the resource requirements of the subtasks are selected.

[0185] In this embodiment, a binary matching algorithm is used to split a resource-intensive task into multiple subtasks, which are then distributed to multiple nodes for parallel processing. A subtask is an independent computing unit formed by logically or data-wise splitting the original large task, and its requirements are determined by the task splitting strategy. For example, if the original task needs to process 1TB of data, it can be divided into 10 subtasks, each processing 100GB. In this case, the subtask's requirement is the computing power needed to process 100GB of data (e.g., 10 TFLOPS). During the splitting process, the cloud management platform combines the average computing power of the nodes (e.g., 20 TFLOPS) and the "1.2 times" matching condition to ensure that the node resources allocated to each subtask (e.g., ≥12 TFLOPS) can efficiently complete the computation while avoiding cluster fragmentation due to resource overload (i.e., large nodes being occupied by small tasks and unable to handle subsequent large tasks).

[0186] Optionally, a binary matching algorithm is used to break down large resource requests into multiple subtasks, which are then distributed to multiple nodes for parallel processing, including:

[0187] The multiple subtasks of the task to be processed are taken as the left vertices of the bipartite graph, the nodes are taken as the right vertices of the bipartite graph, and the edges of the bipartite graph are taken as the correspondence between the subtasks and the nodes.

[0188] For example, suppose we need to process a large task that includes three subtasks (T1, T2, T3), and the cluster has four available nodes (N1, N2, N3, N4). Each subtask has explicit resource requirements (such as computing power), and each node has remaining computing power.

[0189] Vertex partitioning:

[0190] Left vertex set (U): {T1, T2, T3} (subtask)

[0191] The set of vertices on the right (V): {N1, N2, N3, N4} (nodes)

[0192] Edge connection rules:

[0193] If the remaining resources of node Ni are ≥ 1.2 times the requirements of subtask Tj, then connect edge (Tj, Ni).

[0194] For example: if T1 requires 10 TFLOPS and N1 has 15 TFLOPS remaining (≥12 TFLOPS), then connect (T1, N1); if N2 has only 8 TFLOPS remaining, then do not connect.

[0195] Left-hand nodes represent subtasks (e.g., subtask 1 requires 50 TFLOPS, subtask 2 requires 50 TFLOPS). Subtask requirements are typically determined by a task splitting strategy combined with resource granularity requirements. For example, if the original task requires 100 TFLOPS of computing power, the system can split it into two subtasks based on the average performance of nodes (e.g., a single node can support a maximum of 60 TFLOPS), allocating 50 TFLOPS to each, ensuring that a single node can handle the load and avoiding overload. Data locality (e.g., assigning related data to the same subtask) and load balancing (making the requirements of each subtask similar) are also considered during splitting. If a task contains independent modules (e.g., different frames in video encoding), it can also be directly divided by module. The final requirement is calculated comprehensively based on task characteristic analysis, resource constraints, and scheduling objectives (e.g., low latency).

[0196] Right-hand node: indicates allocable nodes (e.g., node A has 60 TFLOPS remaining, node B has 70 TFLOPS remaining).

[0197] Edge weight: Represents the matching priority, usually based on the degree of matching between the node's remaining resources and the subtask requirements.

[0198] Optionally, based on the resource weight, demand deviation rate, deviation weight of each subtask, and the remaining computing power of the second target node, the second target node corresponding to each subtask is determined, including:

[0199] Determine the matching degree between each subtask and the second target node;

[0200] The second target node corresponding to each subtask is determined based on the matching degree;

[0201] Wherein, the matching degree = (remaining computing power × resource weight) + (1 - demand deviation rate × deviation weight);

[0202] The resource weight is determined based on the type of the subtask;

[0203] Demand deviation rate = |Remaining computing power - Resource requirements of subtasks| / Resource requirements of subtasks;

[0204] The deviation weight is inversely proportional to the demand deviation rate.

[0205] Node remaining computing power: The current available computing power of the node (e.g., 80 TFLOPS). The larger the value, the higher the priority.

[0206] Resource weight: A coefficient that adjusts the importance of resources (e.g., 0.7). If resources are the primary constraint, a high value is set.

[0207] Subtask requirement deviation rate: |Node remaining resources - Subtask requirement| / Subtask requirement (e.g., when the requirement is 50 TFLOPS, the deviation rate is (80-50) / 50=0.6).

[0208] Bias weight: A coefficient (e.g., 0.3) that penalizes resource surplus or shortage; the lower the bias rate, the higher the weight.

[0209] The final edge weight = matching degree × normalization factor, ensuring that the value is within a reasonable range.

[0210] It's important to note that while the bipartite graph algorithm can visually show which subtasks can be assigned to which nodes, it only assigns subtasks to nodes capable of handling them, rather than performing a globally optimal match between subtasks and nodes. Therefore, it cannot optimize resource allocation for each node. The Hungarian algorithm, by iteratively adjusting vertex labels and finding augmenting paths, can ultimately output the maximum weighted matching result that satisfies constraints (e.g., node resources ≥ 1.2 times the subtask requirements), achieving efficient resource allocation.

[0211] For example, a task with a resource requirement of 200 TFLOPS is split into 4 subtasks (each subtask has a resource requirement of 50 TFLOPS).

[0212] Allocable nodes:

[0213] Node A: 60 TFLOPS remaining;

[0214] Node B: 70 TFLOPS remaining;

[0215] Node C: 80 TFLOPS remaining;

[0216] Node D: 90 TFLOPS remaining;

[0217] Matching process:

[0218] Subtask 1 → Node A (60 ≥ 50 × 1.2);

[0219] Subtask 2 → Node B (70 ≥ 50 × 1.2);

[0220] Subtask 3 → Node C (80 ≥ 50 × 1.2);

[0221] Subtask 4 → Node D (90 ≥ 50 × 1.2).

[0222] Optionally, the method further includes:

[0223] If no node matching the first subtask is found in the second target node, the node sequence is checked at preset intervals to determine the third target node corresponding to the first subtask; or,

[0224] If no matching node for the first subtask is found in the second target node after a preset time threshold, the target resource for the target task in the fourth target node is released, and the first subtask is processed on the target resource in the fourth target node; the target task is a task with a lower priority than the first subtask, and the task priority is determined based on at least one of the task's resource requirements, task type, and latency requirements; the target resource is at least a portion of the resources used to process the target task.

[0225] For example, the node sequence is updated in real time:

[0226] The allocatable set is updated every 10 seconds: This update dynamically reflects the real-time resource status of the cluster (such as changes in node load and resource release by new tasks), ensuring that subsequent task allocation is based on the latest data. Updates and task allocation are independent cycles: After allocation, the set continues to be updated to provide accurate candidate nodes for new tasks or retry queues, rather than maintaining three static lists.

[0227] The specific address, and the update of the node sequence, includes:

[0228] Remove faulty nodes (nodes with heartbeat timeouts > 3).

[0229] Dynamically adjust node sorting weights:

[0230] Sorting weight = 0.6 remaining computing power + 0.3 (1 / delayed data) + 0.1 historical success rate.

[0231] Optionally, the method also includes:

[0232] If the number of the first target nodes is less than the number of the first tasks, the first tasks will be assigned to the first target nodes and the fifth target nodes.

[0233] The fifth target node is a node other than the candidate nodes. The remaining computing power of the fifth target node is greater than the resource requirements of the first task, and the latency data of the fifth target node is less than the latency requirements of the first task.

[0234] It should be noted that the fifth target node is an edge node (such as a base station and a corporate campus) that is geographically close to the user or data source.

[0235] Specifically, an edge computing power subset is set up and updated every preset time interval; if the first target node is insufficient to allocate the first task, some of the first tasks are allocated to the fifth target node for processing.

[0236] It's important to note that the edge computing power subset is a subset of globally available nodes designed to reduce latency and improve real-time performance. This subset is dynamically evaluated and filtered every 10 seconds: only nodes with latency below a threshold (e.g., <20ms) and performance (computing power, bandwidth) meeting the requirements of edge tasks (such as edge AI inference and IoT data processing) are retained; other nodes (e.g., high-computing-power but high-latency nodes in the cloud) are excluded. Its purpose is to provide a dedicated candidate pool for latency-sensitive tasks, ensuring that tasks are preferentially allocated to near-end resources, thereby improving response speed.

[0237] For example, the node selection criteria for a subset of edge computing power:

[0238] Network latency ≤20ms (based on a comprehensive evaluation of the physical distance between the node and the requesting node, network bandwidth, and real-time link quality).

[0239] Hardware performance meets task requirements (e.g., GPU computing power ≥ 100 TFLOPS, memory ≥ 32GB);

[0240] Subset dynamic update: Re-evaluate node latency and performance every 10 seconds and update the edge computing power subset.

[0241] Example:

[0242] Candidate nodes: Node A (delay 15ms), Node B (delay 18ms), Node C (delay 25ms);

[0243] Edge computing power subset selection results: Node A, Node B (latency ≤ 20ms).

[0244] Optionally, assigning the first task to the first target node and the fifth target node includes:

[0245] Assign the second task from the first task to the fifth target node;

[0246] The second task is a task with a latency requirement of less than a second preset latency, and the second preset latency is less than the first preset latency.

[0247] The determination of the fifth target node is to ensure that latency-sensitive tasks prioritize the use of edge node resources, thereby avoiding a decline in user experience due to network latency.

[0248] For example, the allocation process for the second task is as follows:

[0249] The task is assigned to the node with the lowest latency from the edge computing power subset.

[0250] The resource scheduling method of this application can meet the response speed requirements of latency-sensitive tasks by forcibly allocating resources to them, thus avoiding a decline in user experience due to network latency.

[0251] For example, the resource allocation formula is: Allocation amount = min(Requested resources, Node's remaining resources × 0.8)

[0252] For example, the second task requires 50 TFLOPS, node A has 60 TFLOPS remaining, and 48 TFLOPS (60 × 0.8) are allocated.

[0253] The second task requirement: real-time gesture recognition (priority 1), requiring 50 TFLOPS, latency ≤20ms;

[0254] Subset nodes: Node A (delay 15ms, 60 TFLOPS remaining), Node B (delay 18ms, 40 TFLOPS remaining);

[0255] Allocation result: Node A is allocated 48 TFLOPS, and the remaining 2 TFLOPS are placed in the allocation queue.

[0256] Optionally, the method further includes:

[0257] If the number of the first target nodes is less than the number of the first task, and the processing flow of the fourth task is running on the sixth target node, release the resources occupied by the fourth task.

[0258] Assign the fifth task to the sixth target node;

[0259] The sixth target node is a node among the candidate nodes, and the resources occupied by the fourth task are greater than the resource requirements of the first task.

[0260] It should be noted that when introducing preemptive scheduling on the basis of "first-come, first-served", if there is a high-priority task (such as priority 1) in the queue and the submission time is late, the system will immediately interrupt the currently running low-priority task (such as priority 3), release the resources it occupies (such as computing power and memory), and put the high-priority task into execution.

[0261] Specifically:

[0262] When a high-priority task is detected to be enqueued, a preemption check is triggered.

[0263] If the priority of the currently running task is lower than that of the new task, then mark it as interruptible;

[0264] Reclaim allocated resources from interruptible tasks (e.g., no more than 50% of their actual usage to avoid over-reclaiming) and reallocate them to high-priority tasks.

[0265] The preempted task is moved back to the head of the queue, retaining its execution progress for later recovery.

[0266] For example:

[0267] Task 1: Submission deadline 10:00, 50 TFLOPS required;

[0268] Task 2: Submission time 10:05, 30 TFLOPS required;

[0269] Resource status: No free nodes from 10:00 to 10:10; Node A is free at 10:10 (60 TFLOPS remaining).

[0270] Allocation results:

[0271] At 10:10, Task 1 was allocated 50 TFLOPS, and Task 2 continues to wait.

[0272] At 10:15, Task 2 is allocated 30 TFLOPS (if there are no resources before 10:15, Task 2 will be cancelled).

[0273] Optionally, if the resources of the edge node subset still do not meet the first task, the expansion of the edge node subset is initiated.

[0274] Optionally, if the resources of the subset of edge nodes are still insufficient to process the first task, the edge nodes are expanded.

[0275] For example, the expansion trigger condition is:

[0276] The load of all nodes within the specified subset of edge nodes is >85%;

[0277] The waiting time for latency-sensitive tasks in the queue to be assigned is >1 minute.

[0278] Expansion methods:

[0279] Public cloud: Launch edge computing instances (such as AWS Wavelength, latency ≤5ms);

[0280] Private cloud: scheduling reserved edge servers (such as the NVIDIA EGX edge computing platform);

[0281] Capacity expansion: Each expansion adds 2-4 edge nodes to ensure sufficient resources.

[0282] Example:

[0283] Subset nodes: Node A (load 90%), Node B (load 88%).

[0284] Expansion Triggered: Add node C (delay 10ms, remaining 100 TFLOPS) and node D (delay 12ms, remaining 80 TFLOPS).

[0285] Allocation result: The task is assigned to node C (48 TFLOPS).

[0286] Optionally, determining the node corresponding to each task to be processed based on the computing power request and the node sequence includes:

[0287] If the latency requirement of the third task in the pending tasks is greater than the third preset latency, and the nodes in the candidate node set are in an idle state, the remaining computing power of the candidate nodes shall be allocated to the third task in no more than a preset proportion.

[0288] The third preset delay is greater than the first preset delay.

[0289] Optionally, the preset ratio is less than or equal to 50%.

[0290] It should be noted that, while ensuring the resource requirements of high-priority (latency-sensitive) tasks, and making full use of node idle time periods to avoid resource waste, low-priority (latency-insensitive) tasks can be processed by utilizing the idle state of nodes in the node sequence. For example, a lazy allocation strategy can be used to allocate latency-insensitive tasks:

[0291] Idle time period definition: A node load of less than 40% is considered an idle time period;

[0292] Allocation rules:

[0293] Resources are allocated to static resource preloading tasks only during node idle periods: the allocation amount does not exceed 50% of the node's remaining resources, ensuring that high-priority tasks can preempt resources at any time; the node's remaining resources are essentially the same as the remaining computing power mentioned above, but the concept is broader, usually referring to the total amount of all available resources that the node is currently not occupied, including computing power (such as TFLOPS), memory capacity (GB), storage bandwidth, etc.

[0294] The resources in "allocation not exceeding 50% of the remaining resources" here are primarily computing power by default (e.g., if there are 100 TFLOPS remaining, a maximum of 50 TFLOPS will be allocated). However, if the task is memory-sensitive, the memory usage ratio may also be constrained.

[0295] It should be noted that this rule does not conflict with the remaining computing power. Instead, it reserves resource buffer space for high-priority tasks through a uniform ratio limit (such as 50%), ensuring that they can preempt the allocated resources of low-priority tasks at any time.

[0296] Example:

[0297] Node A: Current load 30%, remaining resources 80 TFLOPS.

[0298] Task requirement: Preloading tasks require 40 TFLOPS.

[0299] Allocation result: Node A is allocated 40 TFLOPS (≤80×50%), and the remaining 40 TFLOPS are reserved.

[0300] The various methods described above are based on embodiments of this application. Apparatus for implementing the above methods will now be provided.

[0301] like Figure 2 As shown in the figure, this application embodiment also provides a resource scheduling method apparatus 200, including:

[0302] The receiving module 201 is used to receive the computing power request of the first node; the computing power request includes the resource requirements, task types and latency requirements of multiple tasks to be processed;

[0303] The acquisition module 202 is used to acquire the status parameters of the candidate node; the status parameters include at least one of the following: the load, remaining computing power, historical task success rate, and latency data between the first node and the candidate node of the candidate node;

[0304] The determination module 203 is used to determine the node corresponding to each of the candidate nodes for the task to be processed based on the computing power request and the status parameters of the candidate nodes.

[0305] The resource scheduling device provided in this application analyzes the computing power request of the first node to determine the resource requirements, task type, and latency requirements of the task to be processed by the first node. It then determines the node corresponding to the task to be processed among the candidate nodes based on at least one of the candidate node's status parameters, including the candidate node's load, remaining computing power, historical task success rate, and latency data between the first node and the candidate nodes. Thus, it selects the corresponding node for task processing according to the different resource requirements, task type, and latency requirements of the task to be processed, thereby maximizing the resource utilization of the candidate nodes while ensuring the processing latency of the task to be processed.

[0306] like Figure 3As shown in the figure, this application embodiment also provides a network device 300, including: a transceiver 301 and a processor 302;

[0307] The transceiver 301 is used to receive computing power requests from the first node; the computing power requests include resource requirements, task types, and latency requirements for multiple tasks to be processed.

[0308] Obtain the status parameters of the candidate node; the status parameters include at least one of the following: the load, remaining computing power, historical task success rate, and latency data between the first node and the candidate node of the candidate node;

[0309] The processor 302 is used to determine the node corresponding to each of the candidate nodes for the task to be processed based on the computing power request and the status parameters of the candidate nodes.

[0310] like Figure 4 As shown, this application embodiment also provides a network device 400, including a processor 401, a memory 402, and a computer program stored in the memory 402 and executable on the processor 401. When the computer program is executed by the processor 401, it implements the various processes of the above-described resource scheduling method embodiment and can achieve the same technical effect. To avoid repetition, it will not be described again here.

[0311] This application also provides a computer-readable storage medium storing a computer program. When executed by a processor, the computer program implements the various processes of the resource scheduling method embodiments described above and achieves the same technical effects. To avoid repetition, it will not be described again here. The computer-readable storage medium may be a read-only memory (ROM), a random access memory (RAM), a magnetic disk, or an optical disk, etc.

[0312] This application also provides a computer program product, including computer instructions. When executed by a processor, the computer instructions implement the various processes of the above-described resource scheduling method embodiments and achieve the same technical effects. To avoid repetition, they will not be described again here.

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

[0314] Through the above description of the embodiments, those skilled in the art can clearly understand that the methods of the above embodiments can be implemented by means of software plus necessary general-purpose hardware platforms. Of course, they can also be implemented by hardware, but in many cases the former is a better implementation method. Based on this understanding, the technical solution of this application, in essence, or the part that contributes to the prior art, can be embodied in the form of a software product. This computer software product is stored in a storage medium (such as ROM / RAM, magnetic disk, optical disk) and includes several instructions to cause a terminal (which may be a mobile phone, computer, server, air conditioner, or network device, etc.) to execute the methods described in the various embodiments of this application.

[0315] It should be noted that the collection, gathering, updating, analysis, processing, use, transmission, and storage of user personal information involved in this disclosed technical solution all comply with relevant laws and regulations, are used for legitimate purposes, and do not violate public order and good morals. Necessary measures are taken to prevent unauthorized access to user personal information data and to safeguard user personal information security and network security.

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

[0317] Through the above description of the embodiments, those skilled in the art can clearly understand that the methods of the above embodiments can be implemented by means of software plus necessary general-purpose hardware platforms. Of course, they can also be implemented by hardware, but in many cases the former is a better implementation method. Based on this understanding, the technical solution of this application, in essence, or the part that contributes to the prior art, can be embodied in the form of a software product. The computer software product is stored in a storage medium (such as ROM / RAM, magnetic disk, optical disk) and includes several instructions to cause a terminal (which may be a mobile phone, computer, server, air conditioner, or network device, etc.) to execute the methods described in the various embodiments of this application.

[0318] The embodiments of this application have been described above with reference to the accompanying drawings. However, this application is not limited to the specific embodiments described above. The specific embodiments described above are merely illustrative and not restrictive. Those skilled in the art can make many other forms under the guidance of this application without departing from the spirit and scope of the claims, and all of these forms are within the protection scope of this application.

Claims

1. A resource scheduling method, applied to a first server, characterized in that, include: Receive computing power requests from the first node; the computing power requests include the resource requirements, task types, and latency requirements of multiple tasks to be processed; Obtain the status parameters of the candidate node; the status parameters include at least one of the following: the load, remaining computing power, historical task success rate, and latency data between the first node and the candidate node of the candidate node; The node corresponding to each task to be processed among the candidate nodes is determined based on the computing power request and the status parameters of the candidate nodes.

2. The resource scheduling method according to claim 1, characterized in that, Determining the node corresponding to each task to be processed among the candidate nodes based on the computing power request and the status parameters of the candidate nodes includes: The candidate node set is determined based on the load and remaining computing power of the candidate nodes; The nodes in the candidate node set are sorted by priority to obtain a node sequence; the priority is determined based on at least one of the remaining computing power, historical task success rate, and latency data between the first node and the candidate nodes. Based on the computing power request and the node sequence, determine the node corresponding to each of the candidate nodes for the task to be processed.

3. The resource scheduling method according to claim 2, characterized in that, Based on the computing power request and the node sequence, the node corresponding to each task to be processed is determined, including: If the latency requirement of the first task in the pending tasks is less than the first preset latency, determine the first target node in the node sequence corresponding to the first task; The first target node is the node with the smallest delay data in the node sequence.

4. The resource scheduling method according to claim 3, characterized in that, Also includes: The same task to be processed is processed simultaneously on multiple first target nodes; Upon receiving the processing result for the task to be processed, stop all processing of the task to be processed by the first target nodes.

5. The resource scheduling method according to claim 2, characterized in that, Based on the computing power request and the node sequence, the node corresponding to each task to be processed is determined, including: If the resource requirements of the task to be processed exceed a preset threshold, the task to be processed will be split into multiple sub-tasks. Identify multiple second target nodes in the node sequence; the second target nodes are nodes in the node sequence whose remaining computing power is greater than the resource requirements of the subtask. Based on the resource weight, demand deviation rate, deviation weight of each subtask, and the remaining computing power of the second target node, the second target node corresponding to each subtask is determined.

6. The resource scheduling method according to claim 5, characterized in that, Based on the resource weight, demand deviation rate, deviation weight of each subtask, and the remaining computing power of the second target node, the second target node corresponding to each subtask is determined, including: Determine the matching degree between each subtask and the second target node; The second target node corresponding to each subtask is determined based on the matching degree; Wherein, the matching degree = (remaining computing power × resource weight) + (1 - demand deviation rate × deviation weight); The resource weight is determined based on the type of the subtask; Demand deviation rate = |Remaining computing power - Resource requirements of subtasks| / Resource requirements of subtasks; The deviation weight is inversely proportional to the demand deviation rate.

7. The resource scheduling method according to claim 5, characterized in that, Also includes: If there is no node in the second target node that matches the first subtask, the node sequence is detected at preset intervals to determine the third target node corresponding to the first subtask. or, If no node matching the first subtask exists in the second target node after a preset time threshold, the target resource for the target task in the fourth target node is released, and the first subtask is processed on the target resource in the fourth target node. The target task is a task with a priority lower than the first subtask. The task priority is determined based on at least one of the task's resource requirements, task type, and latency requirements. The target resource is at least a portion of the resources used to process the target task.

8. The resource scheduling method according to claim 3, characterized in that, Also includes: If the number of the first target nodes is less than the number of the first tasks, the first tasks will be assigned to the first target nodes and the fifth target nodes. The fifth target node is a node other than the candidate nodes. The remaining computing power of the fifth target node is greater than the resource requirements of the first task, and the latency data of the fifth target node is less than the latency requirements of the first task.

9. The resource scheduling method according to claim 8, characterized in that, Assigning the first task to the first target node and the fifth target node includes: Assign the second task from the first task to the fifth target node; The second task is a task with a latency requirement of less than a second preset latency, and the second preset latency is less than the first preset latency.

10. The resource scheduling method according to claim 3, characterized in that, Based on the computing power request and the node sequence, the node corresponding to each task to be processed is determined, including: If the latency requirement of the third task in the pending tasks is greater than the third preset latency, and the nodes in the candidate node set are in an idle state, the remaining computing power of the candidate nodes shall be allocated to the third task in no more than a preset proportion. The third preset delay is greater than the first preset delay.

11. A resource scheduling method apparatus, characterized in that, include: The receiving module is used to receive the computing power request from the first node; the computing power request includes the resource requirements, task types and latency requirements of multiple tasks to be processed; The acquisition module is used to acquire the status parameters of the candidate node; the status parameters include at least one of the following: the load, remaining computing power, historical task success rate, and latency data between the first node and the candidate node of the candidate node; The determination module is used to determine the node corresponding to each of the candidate nodes for the task to be processed based on the computing power request and the status parameters of the candidate nodes.

12. A network device, characterized in that, Includes transceivers and processors, among which, The transceiver is used to receive computing power requests from the first node; the computing power requests include the resource requirements, task types, and latency requirements of multiple tasks to be processed. Obtain the status parameters of the candidate node; the status parameters include at least one of the following: the load, remaining computing power, historical task success rate, and latency data between the first node and the candidate node of the candidate node; The processor is configured to determine the node corresponding to each of the candidate nodes for the task to be processed based on the computing power request and the status parameters of the candidate nodes.

13. A network device, characterized in that, include: A processor, a memory, and a program stored in the memory and executable on the processor, the program, when executed by the processor, implementing the steps of the method as described in any one of claims 1 to 10.

14. A computer-readable storage medium, characterized in that, The computer-readable storage medium stores a computer program that, when executed by a processor, implements the steps of the method as described in any one of claims 1 to 10.

15. A computer program product, characterized in that, Includes computer instructions that, when executed by a processor, implement the steps of the method as described in any one of claims 1 to 10.

Images