Distributed computing power scheduling method and system based on dynamic load balancing

Abstract

The invention relates to the technical field of distributed computing, and discloses a distributed computing power scheduling method and system based on dynamic load balancing. The method comprises the following steps: acquiring real-time resource state data of a plurality of nodes in the distributed system and demand characteristics of a task to be allocated, generating a dynamic task allocation strategy, allocating the task to a target node for execution, monitoring a resource state of the target node in real time, and triggering task reallocation when the resource state deviates from a preset threshold value. The system comprises a monitoring acquisition module, a task analysis module, a strategy generation module, a scheduling execution module and a resource abstraction module. According to the method, tasks and node resources can be accurately matched, the resource utilization rate is improved, the real-time performance and reliability of the tasks are guaranteed, the overall performance of a distributed system is optimized through heterogeneous resource unified scheduling and a resource reserving and recycling mechanism, and the method is suitable for various distributed computing scenes.

Description

Technical Field

[0001] The present invention relates to the field of distributed computing technology, and specifically to a distributed computing power scheduling method and system based on dynamic load balancing. Background Art

[0002] In today's digital age, data volumes are exploding, and the complexity and scale of various computing tasks are also increasing. This has necessitated the emergence of distributed computing technology. By distributing computing tasks across multiple nodes for collaborative processing, distributed computing can significantly improve computing power and meet the demands of large-scale data processing and complex computations. However, in practical applications, computing power scheduling in distributed systems faces numerous challenges. As distributed systems continue to scale, the number of nodes increases, and resource types become increasingly complex. Hardware configurations vary between nodes, such as CPU performance, GPU processing power, and FPGA features, as well as memory capacity and storage bandwidth. This makes it difficult to precisely match task requirements with node resources during task allocation, leading to uneven resource utilization. Some nodes may sit idle while others are overloaded, impacting overall system performance.

[0003] Traditional static task allocation methods are no longer able to meet dynamically changing task demands. In actual operations, the computational load, data volume, and latency requirements of tasks can change at any time. For example, in real-time video processing, fluctuations in video frame rates can lead to dynamic changes in computational load. During e-commerce promotions, a large number of order processing tasks have extremely high latency requirements and enormous data volumes. Using a static allocation strategy, resources cannot be adjusted promptly based on task changes, which can easily lead to task backlogs, low execution efficiency, and even failure to meet real-time requirements.

[0004] Different types of computing tasks have vastly different resource requirements. For example, deep learning tasks require significant GPU computing resources, while data storage and retrieval tasks rely more heavily on storage bandwidth and memory. Existing computing power scheduling methods struggle to uniformly and efficiently manage and schedule heterogeneous resources, failing to fully leverage the strengths of various resources, leading to resource waste and system performance bottlenecks.

[0005] Furthermore, the widespread adoption of distributed systems in key sectors such as finance, healthcare, and industrial manufacturing has placed higher demands on the reliability and stability of task execution. Failure to promptly migrate tasks will lead to task interruption and serious consequences if a node fails or its resources become overloaded. However, many current computing power scheduling systems lack effective dynamic task reallocation mechanisms, making them unable to guarantee the continued and stable execution of tasks in the event of node anomalies.

[0006] In practical application scenarios, such as big data analysis platforms, cloud computing service providers, and artificial intelligence training centers, the above-mentioned problems have severely restricted the development and application of distributed systems. Therefore, there is an urgent need for a distributed computing power scheduling method and system based on dynamic load balancing to address issues such as uneven resource utilization, inflexible task allocation, difficulty in managing heterogeneous resources, and low task execution reliability, thereby improving the overall performance and competitiveness of distributed systems. Summary of the Invention

[0007] The purpose of the present invention is to provide a distributed computing power scheduling method and system based on dynamic load balancing to solve the problems raised in the above background technology.

[0008] To achieve the above objectives, the present invention provides the following technical solution: a distributed computing power scheduling method based on dynamic load balancing, the method comprising:

[0009] Acquire real-time resource status data of multiple nodes in a distributed system, wherein the resource status data includes at least one of CPU utilization, GPU load, and FPGA task queue;

[0010] Obtaining a task requirement characteristic of a task to be assigned, wherein the task requirement characteristic includes at least one of a computational load, a data load, and a delay requirement;

[0011] Generate a dynamic task allocation strategy based on the resource status data and task requirement characteristics, wherein the dynamic task allocation strategy includes task priority division and node matching rules;

[0012] Based on the dynamic task allocation strategy, the task is allocated to the corresponding target node for execution, and the target node is the node that meets the task requirement characteristics and has the best resource status;

[0013] The resource status changes of the target node are monitored in real time. If the resource status is detected to deviate from the preset threshold, dynamic task reallocation is triggered to migrate the task to the new target node.

[0014] Preferably, the obtaining of real-time resource status data comprises the following steps:

[0015] A lightweight monitoring agent is deployed on each node to periodically collect the node's CPU utilization, GPU load, memory usage, and FPGA task queue length;

[0016] Normalize the collected data and convert resource status data of different dimensions into indicators of unified dimensions;

[0017] Resource status data is classified and stored according to node types, including CPU-intensive nodes, GPU-accelerated nodes, and FPGA-specific nodes.

[0018] Preferably, the generating of the dynamic task allocation strategy comprises the following steps:

[0019] According to the delay requirements in the task demand characteristics, tasks are divided into real-time tasks, high-priority tasks and ordinary tasks;

[0020] Set minimum response time constraints for real-time tasks, resource reservation thresholds for high-priority tasks, and elastic scaling rules for common tasks.

[0021] Based on node matching rules, real-time tasks are preferentially assigned to low-load GPU acceleration nodes, high-priority tasks are assigned to pre-configured resource pools, and ordinary tasks are dynamically assigned to remaining available nodes.

[0022] Preferably, the node matching rule includes the following steps:

[0023] Constructing a resource capability vector for each node, the vector including the number of computing cores, memory capacity, storage bandwidth, and accelerator type;

[0024] Constructing a demand vector for each task, including the number of required computing cores, estimated memory usage, and accelerator dependency type;

[0025] Calculate the cosine similarity between the resource capability vector and the demand vector, and select the node with the highest similarity as the candidate target node.

[0026] Preferably, the dynamic task reallocation comprises the following steps:

[0027] When the CPU utilization of the target node exceeds the first threshold or the GPU load exceeds the second threshold, the node is marked as overloaded;

[0028] Nodes whose resource status meets task requirements and whose load is lower than the preset safety value are selected from the candidate node pool as migration targets;

[0029] An incremental migration strategy is adopted to migrate some tasks of the overloaded node to the migration target node in batches according to priority.

[0030] Preferably, the incremental migration strategy includes the following steps:

[0031] Calculate the weight coefficient of task migration based on task priority and remaining execution time;

[0032] Prioritize migrating tasks with high weight coefficients and ensure persistent storage of task execution status during the migration process;

[0033] After the migration is completed, the resources occupied by the migrated tasks in the original target node are released and the resource status data is updated.

[0034] Preferably, the method further includes the following steps:

[0035] Define a unified virtual resource interface for different accelerator types, which encapsulates computing core allocation, memory mapping, and data transfer functions;

[0036] The physical resources of CPU, GPU and FPGA are abstracted into logical resource units through the virtual resource interface;

[0037] According to the characteristics of task requirements, logical resource units are dynamically combined to form a virtual computing cluster that adapts to the task.

[0038] Preferably, the construction of the virtual computing cluster includes the following steps:

[0039] Select the matching physical resource node based on the accelerator dependency type in the task requirement vector;

[0040] Divide isolated logical partitions on selected nodes and allocate exclusive computing core and memory resources to the logical partitions;

[0041] Logical partitions are interconnected through virtual network links to form a unified virtual computing environment across nodes.

[0042] Preferably, the method further includes the steps of resource reservation and recycling:

[0043] Pre-allocate logical partition resources for high-priority tasks and set the resource reservation validity period;

[0044] If the task is not started within the validity period, the reserved resources are released and re-added to the resource pool;

[0045] After the task is completed, the resources of the logical partition are automatically reclaimed and the available status of the virtual resource interface is updated.

[0046] Preferably, the present invention also includes a distributed computing power scheduling system based on dynamic load balancing, the system comprising:

[0047] The monitoring and acquisition module is deployed on each node to collect CPU utilization, GPU load, and FPGA task queue data in real time;

[0048] The task analysis module is used to analyze the computational load, data volume, and latency requirements of the tasks to be assigned and generate task demand characteristics;

[0049] The strategy generation module is used to generate dynamic task allocation strategies and node matching rules based on resource status data and task requirement characteristics;

[0050] The scheduling execution module is used to assign tasks to target nodes and trigger task migration in response to resource status changes;

[0051] The resource abstraction module is used to encapsulate CPU, GPU, and FPGA resources into a unified virtual resource interface, supporting the dynamic combination of logical resource units.

[0052] Compared with the prior art, the present invention has the following beneficial effects:

[0053] In terms of resource management, by deploying a lightweight monitoring agent on each node, periodically collecting data such as CPU utilization, GPU load, memory occupancy, and FPGA task queue length, and performing normalization and classified storage, the resource status of each node can be accurately understood in real time. This allows the system to accurately assign tasks to target nodes with optimal resource status and that meet the requirements based on task demand characteristics, such as the amount of computation, amount of data, and latency requirements. For example, compute-intensive tasks are preferentially assigned to nodes with strong CPU performance and low load; tasks with high real-time requirements are assigned to low-load GPU-accelerated nodes with fast response speeds. This precise resource matching method greatly improves resource utilization, avoids idle and wasted resources, and effectively reduces hardware costs.

[0054] In terms of task scheduling flexibility, real-time tasks, high-priority tasks, and standard tasks are divided according to their latency requirements, and minimum response time constraints, resource reservation thresholds, and elastic scaling rules are set for each task. This means that the system can schedule tasks appropriately based on their importance and urgency. Real-time tasks can be processed in the shortest possible time, ensuring the real-time requirements of scenarios such as real-time video streaming and high-frequency financial trading. High-priority tasks ensure stable and reliable execution through resource reservation, avoiding task failures due to resource competition. Standard tasks can dynamically adjust resource allocation based on system resource availability, fully utilizing remaining resources and improving overall system throughput.

[0055] The node matching rule selects candidate target nodes by constructing a resource capability vector and a demand vector and calculating their cosine similarity, further optimizing task allocation accuracy. This vector similarity-based matching method comprehensively considers multiple factors, including a node's number of computing cores, memory capacity, storage bandwidth, and accelerator type, resulting in a more scientific and rational matching of tasks and node resources. Compared to traditional, simple task allocation methods, this significantly improves task execution efficiency and reduces task waiting and execution times.

[0056] The dynamic task reallocation mechanism is a highlight of the present invention. When the CPU utilization of the target node exceeds the first threshold or the GPU load exceeds the second threshold, the system will promptly mark the node as overloaded, and select nodes from the candidate node pool whose resource status meets the task requirements and whose load is lower than the preset safety value as migration targets, and adopt an incremental migration strategy to migrate some tasks of the overloaded nodes in batches according to priority. This mechanism ensures that tasks can be continuously and stably executed when abnormal situations occur in the nodes, thereby improving the fault tolerance and reliability of the system. For example, in the process of large-scale data processing, if a node suddenly fails or the load is too high, the system can quickly migrate tasks to other nodes to avoid data processing interruption and ensure business continuity.

[0057] The unified scheduling of heterogeneous resources enables the system to define a unified virtual resource interface for different accelerator types, abstracting the physical resources of the CPU, GPU, and FPGA into logical resource units and dynamically combining them to form a virtual computing cluster based on task requirements. This solves the difficulty of managing heterogeneous resources, allowing various types of resources to work together and leverage their respective strengths. For example, in deep learning training tasks, the parallel computing capabilities of the GPU and the specific acceleration functions of the FPGA can be simultaneously utilized, greatly accelerating the training process and improving the efficiency and quality of model training.

[0058] The resource reservation and reclaim mechanism provides reliable resource guarantees for high-priority tasks. Before a task executes, resources from a logical partition are pre-allocated and a validity period is set for the resource reservation. If the task does not start within the validity period, the reserved resources are released and re-added to the resource pool. After the task completes, the resources are automatically reclaimed and the availability status of the virtual resource interface is updated. This mechanism not only ensures the resource requirements of high-priority tasks, but also avoids the waste of resources left idle for extended periods, further improving resource utilization efficiency. BRIEF DESCRIPTION OF THE DRAWINGS

[0059] Figure 1 This is a working principle diagram of the distributed computing power scheduling method based on dynamic load balancing according to the present invention;

[0060] Figure 2 This is a flowchart of matching nodes and tasks in distributed computing power scheduling;

[0061] Figure 3 A schematic diagram of a process for constructing the virtual computing cluster;

[0062] Figure 4 Schematic diagram of the resource reservation and recovery process for high-priority tasks. DETAILED DESCRIPTION

[0063] The following will clearly and completely describe the technical solutions in the embodiments of the present invention in conjunction with the accompanying drawings. Obviously, the described embodiments are only part of the embodiments of the present invention, not all of the embodiments. Based on the embodiments of the present invention, all other embodiments obtained by ordinary technicians in this field without making creative efforts are within the scope of protection of the present invention.

[0064] See also Figure 1-4 The present invention provides a technical solution: a distributed computing power scheduling method based on dynamic load balancing, the method comprising:

[0065] Obtaining real-time resource status data: A distributed system consists of multiple nodes. To fully understand the real-time resource usage of each node, it is necessary to obtain real-time resource status data for these nodes. This data includes at least one of CPU utilization, GPU load, and FPGA task queue. For example, in a distributed system processing big data, some nodes may be primarily responsible for data computation tasks. In this case, CPU utilization and GPU load are key resource status indicators. For nodes dedicated to specific tasks (such as cryptographic operations), the status of the FPGA task queue is even more important.

[0066] Obtaining Task Requirement Characteristics: For the tasks to be assigned, you must thoroughly understand their requirements. These characteristics include at least one of the following: computational load, data volume, and latency requirements. For example, a real-time video stream processing task has a high computational load, extremely high latency requirements, and also involves a certain amount of data processing. Meanwhile, a common file storage task may have a low computational load but a large data volume, with relatively low latency requirements.

[0067] Generate a dynamic task allocation strategy: Based on acquired resource status data and task requirements, a dynamic task allocation strategy is generated. This strategy primarily includes task prioritization and node matching rules. By properly prioritizing tasks, important tasks are prioritized; node matching rules ensure that tasks are accurately assigned to the most appropriate nodes.

[0068] Task allocation and execution: Based on the generated dynamic task allocation strategy, tasks are assigned to the corresponding target nodes for execution. Target nodes are selected to meet the task's requirements and have optimal resource availability. For example, for a task requiring extremely high computational speed, nodes with sufficient CPU and GPU resources and low load are prioritized to ensure rapid task completion.

[0069] Dynamic task reallocation: During task execution, the resource status of the target node is monitored in real time. Once a resource status deviates from a preset threshold, the dynamic task reallocation mechanism is triggered. At this point, the task is migrated to the new target node to ensure continued efficient execution. For example, if a node's CPU utilization is consistently too high, task execution may slow down. In this case, some tasks may need to be migrated to other nodes with free resources.

[0070] The present invention will be further described below in conjunction with Examples 1 to 5:

[0071] Example 1:

[0072] In actual distributed systems, in order to accurately obtain real-time resource status data and generate reasonable dynamic task allocation strategies, the following specific measures are taken:

[0073] The first step is to obtain real-time resource status data. A lightweight monitoring agent is deployed on each node. This agent acts as a "little guard," periodically collecting data on the node's CPU utilization, GPU load, memory usage, and FPGA task queue length. For example, in a cloud computing distributed system, these lightweight monitoring agents collect data every five minutes. The collected data comes from different dimensions, with varying dimensions and units. To facilitate subsequent unified analysis and processing, this data needs to be normalized. For example, CPU utilization may be a percentage, while memory usage may be measured in bytes. Using a specific normalization algorithm, these different dimensional data are converted into metrics with a unified dimension. Assuming linear normalization is used, data such as CPU utilization and memory usage are mapped to the 0-1 range. This facilitates subsequent analysis and comparison.

[0074] After data normalization, resource status data is categorized and stored based on node type. Node types primarily include CPU-intensive nodes, GPU-accelerated nodes, and FPGA-specific nodes. Different node types perform different tasks in the system and focus on storing different data. For CPU-intensive nodes, storage focuses on data closely related to CPU performance, such as CPU utilization and memory usage; GPU-accelerated nodes focus on storing data such as GPU load; and FPGA-specific nodes focus on data such as the FPGA task queue length. This categorized storage allows for quick retrieval of required node resource data during subsequent task allocation and resource scheduling.

[0075] The next step is to generate a dynamic task allocation strategy. Tasks are categorized based on the latency requirements within their requirements. Tasks with extremely high latency requirements, such as processing real-time video streams, are classified as real-time tasks. Important tasks, such as processing financial transaction data, while not requiring as much real-time performance, are classified as high-priority tasks. Ordinary file processing tasks, for example, are classified as normal tasks.

[0076] Different rules are formulated for different types of tasks. Set a minimum response time constraint for real-time tasks. Assume that this constraint time is T1. In actual applications, for real-time video stream processing tasks, T1 may be set to 50 milliseconds to ensure smooth video playback. Set resource reservation thresholds for high-priority tasks. For example, reserve a certain proportion of CPU and memory resources for financial transaction data processing tasks. Assume that the reserved CPU resource ratio is R1 and the memory resource ratio is R2. For ordinary tasks, set elastic scaling rules to dynamically adjust the resources occupied by ordinary tasks according to the actual situation of system resources. For example, when there are many idle system resources, appropriately increase the resource allocation of ordinary tasks to improve the task execution speed; when resources are tight, reduce ordinary task resources and give priority to real-time tasks and high-priority tasks.

[0077] When assigning tasks, real-time tasks are prioritized to low-load GPU-accelerated nodes based on node matching rules. Because GPUs excel at handling real-time, computationally intensive tasks, low-load GPU-accelerated nodes can quickly respond to the demands of real-time tasks. High-priority tasks are assigned to a preconfigured resource pool, which has sufficient resources prepared in advance for these critical tasks, ensuring smooth execution. Standard tasks are dynamically assigned to remaining available nodes, fully utilizing the system's remaining computing resources and improving resource utilization.

[0078] Example 2:

[0079] This embodiment focuses on the specific implementation methods of node matching rules and dynamic task reallocation.

[0080] In terms of node matching rules, a resource capability vector is constructed for each node. The elements in the vector include the number of computing cores, memory capacity, storage bandwidth, and accelerator type. Taking a server node as an example, assuming that its number of computing cores is N1, the memory capacity is M1 (unit: GB), the storage bandwidth is B1 (unit: GB / s), and the accelerator type is A1 (for example, GPU type or FPGA type), then the resource capability vector of the node can be expressed as [N1, M1, B1, A1]. Similarly, a demand vector is constructed for each task. The vector elements include the required number of computing cores, estimated memory usage, and accelerator dependency type. For example, a deep learning training task is estimated to require N2 computing cores, an estimated memory usage of M2 (unit: GB), and an accelerator dependency type of A2 (assuming it is a GPU). Then the demand vector of the task is [N2, M2, A2].

[0081] The candidate target nodes are selected by calculating the cosine similarity between the resource capability vector and the demand vector. The formula for calculating the cosine similarity is:

[0082]

[0083] Among them, x i and y i These are the corresponding elements in the resource capability vector and the requirement vector, respectively, with n being the vector dimension. In this scenario, n = 3 (number of computing cores, memory capacity, accelerator type) or n = 4 (number of computing cores, memory capacity, storage bandwidth, accelerator type). The higher the calculated cosine similarity, the more closely the node's resource capabilities match the task requirements. Selecting the node with the highest similarity as the candidate target node maximizes the task's resource requirements and improves task execution efficiency.

[0084] In terms of dynamic task reallocation, when the CPU utilization of the target node exceeds the first threshold (assuming T CPU ) or the GPU load exceeds the second threshold (assuming T GPU ), the node is marked as overloaded. For example, when the CPU utilization of a node exceeds 80% (i.e., T CPU =80%), or the GPU load exceeds 70% (i.e. T GPU =70%), the node is considered to be in an overloaded state.

[0085] Nodes whose resource status meets the task requirements and whose load is lower than the preset safety value (assuming it is S) are selected from the candidate node pool as migration targets. The candidate node pool is a pre-established collection of all potentially available nodes. During screening, first check whether the node's resources meet the task's requirements such as the number of computing cores and memory usage, and then determine whether its load is lower than the preset safety value. For example, for a task that requires 4 computing cores and 8GB of memory, the nodes in the candidate node pool must have at least 4 available computing cores and more than 8GB of free memory, and the load must be lower than the preset safety value S (assuming S = 50%) before they can be selected as migration targets.

[0086] An incremental migration strategy is used to migrate tasks from overloaded nodes to the target node in batches, based on priority. This strategy avoids excessive system performance fluctuations caused by migrating too many tasks at once. During the migration process, important, high-priority tasks are prioritized to ensure the continued stable operation of the system's critical tasks.

[0087] Example 3:

[0088] In the incremental migration strategy, the weight coefficient of task migration is calculated based on the task priority and the remaining execution time. Assume that the task priority is represented by P, with a value range of 1-5, 5 representing the highest priority; the remaining execution time is represented by T (in seconds). The calculation formula of the weight coefficient W can be designed as follows:

[0089]

[0090] According to this formula, the higher the task priority and the shorter the remaining execution time, the higher its weight coefficient. For example, a task with a priority of 4 and a remaining execution time of 2 seconds has a weight coefficient of

[0091] When migrating tasks, prioritize tasks with high weight coefficients. This is because tasks with high weight coefficients are often more important or nearing completion, and migrating these tasks can minimize the impact on overall system performance. During the migration process, ensure persistent storage of task execution status. For example, for an ongoing data processing task, store key information such as the current processing progress and intermediate results in reliable storage before migration. A distributed file system can be used to store this information, ensuring that after the migration is complete, the task can be restored from the stored state and continue execution without losing previous processing results.

[0092] After the migration is complete, the resources occupied by the migrated tasks on the original target node are released, and the resource status data is updated. For example, if a task on the original target node occupied two computing cores and 4GB of memory, after the migration is complete, these two computing cores and 4GB of memory are marked as available, and the node's resource status data, such as CPU utilization and memory usage, is updated. This allows the system to promptly understand the resource usage of each node, providing accurate data support for subsequent task allocation and scheduling.

[0093] Example 4:

[0094] This embodiment details the steps for implementing unified scheduling of heterogeneous resources, including:

[0095] First, a unified virtual resource interface is defined for different accelerator types. This interface acts as a standardized "adapter," encapsulating functions such as compute core allocation, memory mapping, and data transfer. For example, using GPUs and FPGAs as two different types of accelerators, this unified virtual resource interface allows upper-layer applications to request and use resources in the same way, regardless of the specific hardware details of the underlying accelerator.

[0096] The virtual resource interface abstracts the physical resources of the CPU, GPU, and FPGA into logical resource units. For example, a CPU with eight computing cores can be abstracted into eight logical computing core units; a GPU with 16GB of video memory can be abstracted into multiple logical memory units; and the different functional modules of an FPGA can be abstracted into corresponding logical resource modules. This transforms complex, heterogeneous physical resources into easily manageable and allocable logical resource units.

[0097] Based on the characteristics of task requirements, logical resource units are dynamically combined to form a task-adaptive virtual computing cluster. When building a virtual computing cluster, matching physical resource nodes are selected based on the accelerator dependency type in the task requirement vector. For example, if a deep learning training task relies on GPU acceleration, a node with a GPU is selected. Isolated logical partitions are created on the selected nodes, and exclusive compute core and memory resources are allocated to each logical partition. Assuming the selected node has 8 compute cores and 32GB of memory, a logical partition is created for the deep learning task, with 4 compute cores and 16GB of memory allocated.

[0098] Logical partitions are interconnected via virtual network links, forming a unified virtual computing environment across nodes. These links can be implemented using software-defined networking (SDN) technology, ensuring efficient and stable data transmission between logical partitions on different nodes. In this way, logical resource units on multiple nodes are combined to form a virtual computing cluster that meets task requirements, providing strong support for efficient task execution.

[0099] Example 5:

[0100] This embodiment is used to introduce the operation process of resource reservation and recycling. Pre-allocate logical partition resources for high-priority tasks and set the resource reservation validity period. Taking a bank core transaction system as an example, for some high-priority transaction tasks involving fund transfers, logical partition resources are pre-allocated before the system runs. Assume that a logical partition resource of 2 computing cores and 8GB memory is pre-allocated for a high-priority task, and the resource reservation validity period is set to T reserve (Unit is minutes). In practical applications, T reserve It may be set to 10 minutes to ensure that sufficient resources are available within a certain period of time after the task is initiated.

[0101] If a task is not started within the validity period, the reserved resources are released and re-added to the resource pool. This is to avoid resource waste and improve resource utilization. For example, within the 10-minute reservation validity period, if a high-priority task is not started due to some reason (such as network delay causing the task request to not arrive in time), the system will automatically release the previously allocated 2 computing cores and 8GB of memory resources, re-mark these resources as available, and add them to the system's resource pool for use by other tasks.

[0102] After a task completes, the system automatically reclaims the logical partition's resources and updates the availability status of the virtual resource interface. When a high-priority task completes its computation and processing, the system immediately reclaims the occupied logical partition's resources. For example, after a task uses up two computing cores and 8GB of memory, the system reclaims these resources, updates the availability status of the corresponding resources in the virtual resource interface, and allows other tasks to reapply for these resources. This resource reservation and reclaim mechanism effectively manages system resources, ensuring the execution of high-priority tasks while improving overall resource utilization.

[0103] It should be noted that, in this document, relational terms such as first and second, etc., are used only to distinguish one entity or operation from another entity or operation, and do not necessarily require or imply any actual relationship or order between these entities or operations. Moreover, the terms "comprises," "includes," or any other variations thereof are intended to cover non-exclusive inclusion, such that a process, method, article, or apparatus that includes a list of elements includes not only those elements but also other elements not explicitly listed, or elements inherent to such process, method, article, or apparatus.

[0104] While embodiments of the present invention have been shown and described, it will be appreciated by those skilled in the art that various changes, modifications, substitutions, and variations may be made to these embodiments without departing from the principles and spirit of the invention, and that the scope of the invention is defined by the appended claims and their equivalents.

Claims

1. A distributed computing power scheduling method based on dynamic load balancing, characterized in that: include: Acquire real-time resource status data of multiple nodes in a distributed system, wherein the resource status data includes at least one of CPU utilization, GPU load, and FPGA task queue; Obtaining a task requirement characteristic of a task to be assigned, wherein the task requirement characteristic includes at least one of a computational load, a data load, and a delay requirement; Generate a dynamic task allocation strategy based on the resource status data and task requirement characteristics, wherein the dynamic task allocation strategy includes task priority division and node matching rules; Based on the dynamic task allocation strategy, the task is allocated to the corresponding target node for execution, and the target node is the node that meets the task requirement characteristics and has the best resource status; The resource status changes of the target node are monitored in real time. If the resource status is detected to deviate from the preset threshold, dynamic task reallocation is triggered to migrate the task to the new target node.

2. A distributed computing power scheduling method based on dynamic load balancing according to claim 1, characterized in that: Acquiring real-time resource status data includes the following steps: A lightweight monitoring agent is deployed on each node to periodically collect the node's CPU utilization, GPU load, memory usage, and FPGA task queue length; Normalize the collected data and convert resource status data of different dimensions into indicators of unified dimensions; Resource status data is classified and stored according to node types, including CPU-intensive nodes, GPU-accelerated nodes, and FPGA-specific nodes.

3. A distributed computing power scheduling method based on dynamic load balancing according to claim 2, characterized in that: Generating a dynamic task allocation strategy comprises the following steps: According to the delay requirements in the task demand characteristics, tasks are divided into real-time tasks, high-priority tasks and ordinary tasks; Set minimum response time constraints for real-time tasks, resource reservation thresholds for high-priority tasks, and elastic scaling rules for common tasks. Based on node matching rules, real-time tasks are preferentially assigned to low-load GPU acceleration nodes, high-priority tasks are assigned to pre-configured resource pools, and ordinary tasks are dynamically assigned to remaining available nodes.

4. A distributed computing power scheduling method based on dynamic load balancing according to claim 3, characterized in that: The node matching rule includes the following steps: Constructing a resource capability vector for each node, the vector including the number of computing cores, memory capacity, storage bandwidth, and accelerator type; Constructing a demand vector for each task, including the number of required computing cores, estimated memory usage, and accelerator dependency type; Calculate the cosine similarity between the resource capability vector and the demand vector, and select the node with the highest similarity as the candidate target node.

5. A distributed computing power scheduling method based on dynamic load balancing according to claim 4, characterized in that: The dynamic task reallocation comprises the following steps: When the CPU utilization of the target node exceeds the first threshold or the GPU load exceeds the second threshold, the node is marked as overloaded; Nodes whose resource status meets task requirements and whose load is lower than the preset safety value are selected from the candidate node pool as migration targets; An incremental migration strategy is adopted to migrate some tasks of the overloaded node to the migration target node in batches according to priority.

6. A distributed computing power scheduling method based on dynamic load balancing according to claim 5, characterized in that: The incremental migration strategy includes the following steps: Calculate the weight coefficient of task migration based on task priority and remaining execution time; Prioritize migrating tasks with high weight coefficients and ensure persistent storage of task execution status during the migration process; After the migration is completed, the resources occupied by the migrated tasks in the original target node are released and the resource status data is updated.

7. A distributed computing power scheduling method based on dynamic load balancing according to claim 6, characterized in that: It also includes steps for unified scheduling of heterogeneous resources: Define a unified virtual resource interface for different accelerator types, which encapsulates computing core allocation, memory mapping, and data transfer functions; The physical resources of CPU, GPU and FPGA are abstracted into logical resource units through the virtual resource interface; According to the characteristics of task requirements, logical resource units are dynamically combined to form a virtual computing cluster that adapts to the task.

8. A distributed computing power scheduling method based on dynamic load balancing according to claim 7, characterized in that: The construction of the virtual computing cluster includes the following steps: Select the matching physical resource node based on the accelerator dependency type in the task requirement vector; Divide isolated logical partitions on selected nodes and allocate exclusive computing core and memory resources to the logical partitions; Logical partitions are interconnected through virtual network links to form a unified virtual computing environment across nodes.

9. A distributed computing power scheduling method based on dynamic load balancing according to claim 8, characterized in that: It also includes steps for resource reservation and recovery: Pre-allocate logical partition resources for high-priority tasks and set the resource reservation validity period; If the task is not started within the validity period, the reserved resources are released and re-added to the resource pool; After the task is completed, the resources of the logical partition are automatically reclaimed and the available status of the virtual resource interface is updated.

10. A distributed computing power scheduling system based on dynamic load balancing, used to implement the method according to any one of claims 1 to 9, characterized in that: include: The monitoring and acquisition module is deployed on each node to collect CPU utilization, GPU load, and FPGA task queue data in real time; The task analysis module is used to analyze the computational load, data volume, and latency requirements of the tasks to be assigned and generate task demand characteristics; The strategy generation module is used to generate dynamic task allocation strategies and node matching rules based on resource status data and task requirement characteristics; The scheduling execution module is used to assign tasks to target nodes and trigger task migration in response to resource status changes; The resource abstraction module is used to encapsulate CPU, GPU, and FPGA resources into a unified virtual resource interface, supporting the dynamic combination of logical resource units.

Images