Big data AI computing power load balancing scheduling management method and system
By adjusting the jump step size using a sliding window and adaptive sensitivity coefficient in big data AI computing load scheduling, the problem of uneven task allocation caused by polling scheduling is solved, and efficient utilization of computing resources is achieved.
Patent Information
- Authority / Receiving Office
- CN · China
- Patent Type
- Applications(China)
- Current Assignee / Owner
- 南京东启新材科技有限公司
- Filing Date
- 2026-04-30
- Publication Date
- 2026-06-19
Smart Images
Figure CN122240275A_ABST
Abstract
Description
Technical Field
[0001] This invention relates to the field of load scheduling technology, specifically to a big data AI computing power load balancing scheduling and management method and system. Background Technology
[0002] In scenarios involving a mix of big data and AI workloads, some computing nodes may be overloaded with GPU memory while others remain idle, resulting in significant waste. However, load balancing scheduling can monitor the load of all computing nodes in real time and intelligently allocate new tasks to the most idle or suitable machines. When necessary, it can also migrate, preempt, or compress tasks, ensuring both the response speed of training and inference tasks and maximizing the utilization of the entire cluster's computing power. This allows more AI services to be run with the same amount of hardware.
[0003] In existing technologies, the computing load is scheduled using a round-robin scheduling algorithm. However, this algorithm has a flaw: if node A has a large backlog of requests while node B is idle, the round-robin algorithm will still indiscriminately allocate new requests to node A, leading to increased queue congestion. Summary of the Invention
[0004] To address the shortcomings of existing technologies, this invention provides a big data AI computing power load balancing scheduling and management method and system, which solves the problem that polling scheduling ignores the current backlog of requests on nodes. Even if node A is severely congested while node B is idle, it will still continue to allocate new tasks to A, thereby exacerbating the queue imbalance.
[0005] To achieve the above objectives, the present invention provides the following technical solution: a big data AI computing power load balancing scheduling and management method, comprising the following specific steps: S1: Arrange all healthy computing nodes in a fixed order as a static node array, initialize the global pointer to point to the first node, initialize the sliding window for calculating the arithmetic mean of the node queuing depth, and initialize the adaptive sensitivity coefficient and historical step length memory variable; S2: When a new computing power task arrives at the scheduler, trigger a scheduling decision; S3: Read the current queuing depth of the node pointed to by the current pointer and obtain the current global average depth; S4: Calculate the basic step length based on the ratio of the current node queuing depth to the global average depth, correct it using the adaptive sensitivity coefficient and historical step length memory variable to obtain the actual jump step length, then jump backward by this step length, update the historical step length memory variable and the adaptive sensitivity coefficient; repeat this jump and update process until the first node with a queuing depth not exceeding the global average depth is found, and a new task is assigned; S5: Point the pointer to the next node of the node to which the task is assigned, and if it exceeds the end of the array, wrap around it; S6: Wait for the next task to arrive, repeat S2 to S5, and update the global average depth periodically; the updated adaptive sensitivity coefficient and historical step size memory variable are naturally carried over to the next scheduling without additional reset.
[0006] Furthermore, the current global average depth is obtained as follows: the scheduler records the real-time queuing depth of all healthy computing nodes through a sliding window, counts the number of all healthy computing nodes at the current moment to obtain the number of nodes, sums the real-time queuing depths of all healthy computing nodes and divides by the number of nodes to obtain the global average depth.
[0007] Furthermore, the actual jump step length is obtained as follows: the current queue depth is compared with the global average depth. If the current queue depth is less than or equal to the global average depth, the basic step length is 1. Otherwise, the basic step length is equal to the current queue depth divided by the global average depth, rounded down, and then 1 is added. Then, the basic step length is exponentially decayed and corrected using the current adaptive sensitivity coefficient and the historical step length memory variable to obtain the actual jump step length.
[0008] Furthermore, the specific method of the exponential decay correction is as follows: a decay factor is preset, the basic step size is multiplied by the adaptive sensitivity coefficient to obtain the sensitivity adjustment value, the historical step size memory variable is multiplied by the decay factor to obtain the memory decay value, the sensitivity adjustment value and the memory decay value are added together and rounded down, and the actual jump step size is ensured to be at least 1.
[0009] Furthermore, the specific method for jumping backward by this step size is as follows: the scheduler reads the index value of the current pointer in the static node array, adds this index value to the actual jump step size, and obtains a new index value; if the new index value is less than the length of the static node array, the pointer is directly moved to the node corresponding to the new index value; if the new index value is greater than or equal to the length of the static node array, the index is cyclically constrained according to the length of the static node array.
[0010] Furthermore, the method of applying cyclic constraints to the index based on the length of the static node array is as follows: The new index value is moduloed by the length of the static node array, so that the result falls within the valid index range of the static node array, thereby moving the pointer to the node corresponding to the modulo operation.
[0011] Furthermore, the adaptive sensitivity coefficient is updated by adjusting it based on the comparison between the queuing depth of the node before the jump and the global average depth, as well as the size of the previous actual step size.
[0012] Furthermore, the historical step length memory variable is updated by: presetting a memory update factor, multiplying the actual jump step length by the memory update factor, and then updating the historical step length memory variable.
[0013] Furthermore, the method of adjusting based on the comparison between the queuing depth of the node before the jump and the global average depth, as well as the size of the previous actual step size, is as follows: a sensitivity decay coefficient and a sensitivity growth coefficient are preset. If the current node queuing depth is greater than the global average depth and the previous actual step size is greater than 1, then the adaptive sensitivity coefficient is multiplied by the sensitivity decay coefficient; otherwise, if the current node queuing depth is less than or equal to the global average depth and the previous actual step size is equal to 1, then the adaptive sensitivity coefficient is multiplied by the sensitivity growth coefficient.
[0014] A big data AI computing power load balancing scheduling and management system includes the following specific modules: Initialization module: arranging all healthy computing nodes in a fixed order into a static node array, initializing the global pointer to point to the first node, initializing a sliding window for calculating the arithmetic mean of node queuing depths, and initializing adaptive sensitivity coefficients and historical step size memory variables; Task receiving module: triggering scheduling decisions when a new computing power task arrives at the scheduler; Load awareness module: reading the current queuing depth of the node pointed to by the current pointer and obtaining the current global average depth; Adaptive skip scheduling module: calculating the basic step size based on the ratio of the current node queuing depth to the global average depth, and utilizing adaptive... The sensitivity coefficient and historical step size memory variable are adjusted to obtain the actual jump step size. Then, jump backward by this step size, update the historical step size memory variable and the adaptive sensitivity coefficient. This jump and update process is repeated until the first node with a queuing depth not exceeding the global average depth is found, and a new task is assigned. The pointer offset module points the pointer to the next node after the node that assigned the task. If it exceeds the end of the array, it wraps around. The control and state continuation module waits for the next task to arrive, repeats the process from the task receiving module to the pointer offset module, and periodically updates the global average depth. The updated adaptive sensitivity coefficient and historical step size memory variable are naturally carried over to the next scheduling without additional reset.
[0015] Compared with the prior art, the embodiments of the present invention have at least the following advantages or beneficial effects: 1. By setting the current queuing depth of healthy computing nodes in real time and comparing it with the global average depth, the actual jump step size is obtained by using the basic step size and exponential decay correction. This allows the scheduler to actively skip congested nodes with queuing depths exceeding the average value and prioritize the allocation of new tasks to nodes with lighter loads. This fundamentally eliminates the shortcomings of traditional polling scheduling, which ignores queuing depth and allows congested nodes to continue to push tasks onto them.
[0016] 2. By employing a repeated jumping and updating process until the first node with a queuing depth not exceeding the global average depth is found, it ensures that the target node for each allocation is in a non-congested state. At the same time, by dynamically adjusting the adaptive sensitivity coefficient and the historical step size memory variable, scheduling oscillations caused by drastic step size jumps are avoided.
[0017] Of course, any product implementing this invention does not necessarily need to achieve all of the advantages described above at the same time. Attached Figure Description
[0018] Figure 1 This is a flowchart of a big data AI computing power load balancing scheduling and management method according to the present invention. Detailed Implementation
[0019] The technical solutions of the embodiments of the present invention will be clearly and completely described below with reference to the accompanying drawings. Obviously, the described embodiments are only some embodiments of the present invention, and not all embodiments. Based on the embodiments of the present invention, all other embodiments obtained by those skilled in the art without creative effort are within the scope of protection of the present invention.
[0020] It should be noted that, in this document, relational terms such as "first" and "second" are used merely to distinguish one entity or operation from another, and do not necessarily require or imply any such actual relationship or order between these entities or operations. Furthermore, 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.
[0021] Example 1: like Figure 1 As shown, this embodiment of the invention provides a big data AI computing power load balancing scheduling and management method, including the following specific steps: S1: Arrange all healthy compute nodes in a static node array in a fixed order. This involves arranging all online and task-acceptable nodes in the cluster into a list in fixed order according to their IP address or name. This ensures the scheduler has a deterministic node traversal baseline, providing an ordered and conflict-free node index space for subsequent pointer jumps and preventing order disruptions caused by dynamic node additions or removals. Initialize the global pointer to point to the first node; that is, assign the scheduler's global index variable to 0, pointing to the first element of the static node array. This ensures that scheduling starts from the head of the array, either sequentially or by jumps, achieving a fair initial starting point. Initialize the sliding window for compute nodes. The arithmetic mean of the queuing depth is calculated by creating a fixed-size data structure, such as a circular queue, to store the queuing depth samples of each node over a recent period. When the window slides, old samples are discarded and new samples are added, so that the global average depth can dynamically reflect the short-term trend of the cluster load and avoid drastic fluctuations in the average value due to occasional pulses. The adaptive sensitivity coefficient and the historical step size memory variable are initialized. The adaptive sensitivity coefficient is set to 1.0, with a range between 0 and 2.0, indicating that the base step size is not scaled initially and remains neutral. The historical step size memory variable is set to 0, indicating that there is no historical memory for the first scheduling and no historical components are introduced during correction.
[0022] S2: When a new computing task arrives at the scheduler, a scheduling decision is triggered. That is, the scheduler listens to the task queue. Once a new task is detected, such as a training script or inference request, the scheduling process from S3 to S5 is immediately started to ensure that the event-driven mode is adopted, reduce the overhead of idle polling, and ensure timely task allocation. S3: Read the current queuing depth of the node pointed to by the current pointer. That is, the scheduler obtains the real-time number of queued tasks of the corresponding node from the node depth mapping table maintained by itself, according to the index value of the global pointer, and obtains the current global average depth to determine whether the current node is a congested node. It is updated every 10 tasks completed or every 1 second. S4: Calculate the base step size based on the ratio of the current node's queuing depth to the global average depth. This design makes the base step size larger for more congested nodes, realizing the logic of jumping further as the congestion worsens. The congestion level is quantified into an integer step size, guiding the scheduler to quickly bypass heavily congested areas. The actual jump step size is obtained by correcting the step size using an adaptive sensitivity coefficient and historical step size memory variables, avoiding scheduling oscillations caused by drastic changes in step size. At the same time, it enables the scheduler to have short-term memory and adaptability. Then, jump backward by this step size, physically skipping multiple nodes to quickly move away from the congested position, and updating the historical step size memory variables and adaptive sensitivity coefficients. Repeat this jumping and updating process until the first node with a queuing depth not exceeding the global average depth is found, ensuring that the final assigned task falls on an uncongested node, eliminating the defects of polling, and then assigning new tasks. S5: Move the pointer to the next node after the node that just assigned the task. If it exceeds the end of the array, it will wrap around. That is, after the assignment is completed, move the global pointer one level. If it reaches the end of the array, it will be reset to 0 to set a new starting point for the next scheduling, so as to avoid the same node being selected repeatedly and to maintain fairness. S6: Wait for the next task to arrive, repeat S2 to S5, that is, the scheduler enters an idle waiting state. Once a new task is generated, the complete process of task reception, depth reading, jump allocation and pointer offset is re-executed, and the global average depth is updated periodically. That is, at fixed time intervals or after a certain number of tasks are completed, the arithmetic mean of the queuing depth of all healthy nodes is recalculated and the sliding window is refreshed, so that the average depth can follow the changes in cluster load and dynamically adjust the congestion judgment benchmark. The updated adaptive sensitivity coefficient and historical step size memory variable are naturally carried over to the next scheduling without additional reset. That is, the scheduler maintains the current value of the adaptive sensitivity coefficient and historical step size memory variable between two schedulings, without returning to zero or resetting.
[0023] Example 2 differs from Example 1 in that: The current method for obtaining the global average depth is as follows: The scheduler records the real-time queuing depth of all healthy computing nodes through a sliding window, counts the number of healthy computing nodes at the current moment to obtain the number of nodes, which is the number of nodes in the static node array that are online. The global average queuing depth is obtained by summing the real-time queuing depths of all healthy computing nodes and dividing by the number of nodes. ,in, Indicates the global average depth. Indicates the number of nodes. Indicates the first The real-time queuing depth of each node; that is, the global average depth dynamically reflects the overall load level of the cluster, avoiding drastic fluctuations in the average value due to the instantaneous jitter of a single node, and providing a stable benchmark for congestion judgment, because a window that is too large will delay load changes, while a window that is too small will have poor noise resistance; taking healthy nodes instead of all nodes can eliminate the interference of faulty nodes on the average value.
[0024] The actual jump step length is obtained as follows: The current queue depth is compared with the global average depth. If the current queue depth is less than or equal to the global average depth, the basic step size is 1, meaning no jump is needed. Otherwise, the basic step size is equal to the current queue depth divided by the global average depth, rounded down, and then 1 is added to ensure that the minimum basic step size is 1. Rounding down ensures that the step size is an integer. Then, the basic step size is exponentially decayed and corrected using the current adaptive sensitivity coefficient and the historical step size memory variable to avoid mechanical jumps and obtain the actual jump step size.
[0025] The specific method of exponential decay correction is as follows: A preset decay factor of 0.5 is set so that the memory contribution accounts for about half of the step size, which can give sufficient weight to the historical step size without making it dominate the decision. The base step size is multiplied by the adaptive sensitivity coefficient to obtain the sensitivity adjustment value. The historical step size memory variable is multiplied by the decay factor to obtain the memory decay value. The sensitivity adjustment value and the memory decay value are added together and rounded down to achieve a smooth transition, avoid drastic step size jumps, and ensure that the actual jump step size is at least 1 to prevent the step size from being 0, which would lead to an infinite loop.
[0026] The specific method for jumping backward this step length is as follows: The scheduler reads the index of the current pointer in the static node array, adds this index to the actual jump step size, and obtains a new index. If the new index is less than the length of the static node array, the pointer is directly moved to the node corresponding to the new index. If the new index is greater than or equal to the length of the static node array, a loop constraint is applied to the index based on the length of the static node array. That is, the pointer movement uses linear addition and then handles out-of-bounds conditions. If it does not exceed the bounds, it jumps directly; if it exceeds the bounds, a loop constraint is triggered. This enables pointer movement with a non-fixed step size and ensures that it always stays within the valid index range. In other words, the addition-based movement is simple and efficient, and distinguishing out-of-bounds cases facilitates the subsequent separate handling of loop constraints.
[0027] The method for applying cyclic constraints to indices based on the length of the static node array is as follows: The new index value is moduloed by the length of the static node array, so that the result falls within the effective index range of the static node array. This moves the pointer to the node corresponding to the modulo, that is, the index that exceeds the linear range is circularly mapped back into the array. This preserves the jump span but achieves loop traversal. Modulo is the simplest loop constraint method in mathematics, without the need for looping to reduce the length.
[0028] The method for updating the adaptive sensitivity coefficient is as follows: The adaptive sensitivity coefficient is adjusted based on the comparison between the queuing depth of the node before the jump and the global average depth, as well as the size of the previous actual step size. This allows the scheduling strategy to adapt to load changes and avoids over-scheduling or under-scheduling caused by a fixed coefficient.
[0029] The method for updating the historical step size memory variable is as follows: A preset memory update factor, assigned a value of 0.7 based on experience, can smooth out changes in step size and quickly forget old step sizes, preventing long-term accumulated deviations. The actual jump step size is multiplied by the memory update factor to update the historical step size memory variable, so that the influence of historical step size decays exponentially and only the main information of the most recent jump is retained, avoiding interference from outdated memory.
[0030] The adjustment method based on the comparison between the queuing depth of the node before the jump and the global average depth, as well as the size of the previous actual step size, is as follows: A sensitivity decay coefficient and a sensitivity growth coefficient are preset. The sensitivity decay coefficient is set to 0.9 to make the adaptive sensitivity coefficient decrease slowly and avoid scheduling failure caused by sudden changes. The sensitivity growth coefficient is set to 1.1 to make the adaptive sensitivity coefficient increase gently and prevent overshoot. The value range is between 0 and 2 to ensure that the step size correction does not get out of control. If the current node's queuing depth is greater than the global average depth and the previous actual step size is greater than 1, the adaptive sensitivity coefficient is multiplied by the sensitivity decay coefficient; otherwise, if the current node's queuing depth is less than or equal to the global average depth and the previous actual step size is equal to 1, the adaptive sensitivity coefficient is multiplied by the sensitivity growth coefficient.
[0031] Example 3: Initialization module: Arrange all healthy computing nodes in a static node array in a fixed order, initialize the global pointer to point to the first node, initialize the sliding window for calculating the arithmetic mean of the node queuing depth, and initialize the adaptive sensitivity coefficient and historical step size memory variable; Task receiving module: When a new computing task arrives at the scheduler, it triggers a scheduling decision; Load awareness module: Reads the current queuing depth of the node pointed to by the current pointer and obtains the current global average depth; The adaptive jump scheduling module calculates the basic step size based on the ratio of the current node's queuing depth to the global average depth. It then uses the adaptive sensitivity coefficient and historical step size memory variables to correct the actual jump step size. The module jumps backward by this step size and updates the historical step size memory variables and the adaptive sensitivity coefficient. This jump and update process is repeated until the first node with a queuing depth not exceeding the global average depth is found, and a new task is assigned. Pointer offset module: points the pointer to the next node after the node where the task was just assigned; if it exceeds the end of the array, it wraps around. Control and State Continuation Module: Waits for the next task to arrive, repeats the task receiving module to the pointer offset module, and periodically updates the global average depth; the updated adaptive sensitivity coefficient and historical step size memory variable are naturally carried over to the next scheduling without additional reset.
[0032] The preferred embodiments disclosed in this invention are merely examples illustrating feasible implementation methods and are not intended to exhaust all technical details of the invention, nor do they constitute a limitation on the scope of protection of this invention. In practical applications, those skilled in the art can make appropriate adjustments, combinations, or substitutions to the methods or systems described in these embodiments based on specific production conditions, equipment configurations, and process requirements, without departing from the core concept of this invention. For example, the health computing node can collect data either through active heartbeat-based retrieval or through periodic reporting by the node; the size of the sliding window can be dynamically adjusted according to the cluster size and load fluctuation frequency; parameters such as the basic step size, exponential decay factor, sensitivity coefficient, and memory update factor involved in the data processing algorithm can be optimized through offline simulation or online learning during actual deployment; the specific implementation form of the execution unit can be a centralized scheduler, a distributed coordination component, or an agent module embedded in each node. All these changes, as long as they are still based on the core idea of "queue depth comparison, dynamic step size jump, and adaptive parameter adjustment," should be considered within the scope of protection of this invention.
[0033] Furthermore, the technical concepts disclosed in this invention possess universal scalability and adaptability. They are not only applicable to the big data AI computing power load balancing scenario described in the embodiments, but can also be applied in similar technical fields or related industrial processes through analogy, transplantation, or improvement. For example, in cloud-native container scheduling, edge computing task distribution, high-performance computing job queuing, and even traffic flow control and warehouse robot path planning, as long as there is task allocation across multiple service units and each unit has a quantifiable "queue depth" or "busy / idle level," the "dynamic jump-type load-aware allocation" strategy of this invention can be applied. Any logically equivalent substitutions based on the principles, ideas, or framework disclosed in this specification—such as replacing queue depth with CPU / GPU utilization, network queue length, energy consumption indicators, etc., reasonable adjustments to the step order, such as asynchronous execution of periodically updating average values and task allocation, or recombination of module functions, such as merging pointer jump and task migration functions—should all be considered to fall within the spirit and scope of this invention.
[0034] It should be further clarified that the specific descriptions and drawings in the patent documents are for the purpose of assisting in understanding the present invention only, and details such as specific parameter values of 0.5, 0.7, 0.9, 1.1, etc., should not be interpreted as limitations on the claims. The true scope of protection of the present invention should be determined by the content of the claims recorded in the authorized text, and should cover all equivalent technical solutions that comply with the provisions of the Patent Law under these claims. Any implementation method that achieves the same or similar function and similar effect by reasonably changing the technical means under the guidance of the concept of the present invention, such as replacing the modulus operation with a conditional subtraction length loop, or replacing the sliding window arithmetic average with an exponentially weighted moving average, falls within the scope of protection sought by the present invention.
[0035] Therefore, the descriptions in this specification are merely illustrative. Any adjustments to implementation methods, equivalent substitutions of technical features, or further applications based on the concept of this invention, as long as they do not depart from the overall technical approach described in this invention, should be included within the scope of protection of this invention. We encourage those skilled in the art to innovate and optimize based on their understanding of the core of this invention and in conjunction with specific practices, so as to jointly promote the progress and development of related technologies. The core of this invention lies in enabling the scheduler to have the adaptive capability of "sensing congestion and actively skipping lanes." All variations around this core, regardless of how parameters are adjusted or how the implementation language or platform changes, should be respected and protected.
Claims
1. A big data AI computing power load balancing scheduling and management method, characterized in that: The specific steps include the following: S1: Arrange all healthy computing nodes in a fixed order as a static node array, initialize the global pointer to point to the first node, initialize the sliding window to calculate the arithmetic mean of the node queuing depth, and initialize the adaptive sensitivity coefficient and the historical step size memory variable. S2: When a new computing task arrives at the scheduler, a scheduling decision is triggered; S3: Read the current queuing depth of the node pointed to by the current pointer, and get the current global average depth; S4: Calculate the base step size based on the ratio of the current node's queuing depth to the global average depth. Correct the actual jump step size using the adaptive sensitivity coefficient and the historical step size memory variable. Then jump backward by this step size and update the historical step size memory variable and the adaptive sensitivity coefficient. Repeat this jumping and updating process until the first node with a queuing depth not exceeding the global average depth is found, and a new task is assigned. S5: Move the pointer to the next node after the node that assigned the task; if it goes beyond the end of the array, wrap around it. S6: Wait for the next task to arrive, repeat S2 to S5, and update the global average depth periodically; the updated adaptive sensitivity coefficient and historical step size memory variable are naturally carried over to the next scheduling without additional reset.
2. The big data AI computing power load balancing scheduling and management method according to claim 1, characterized in that: The current global average depth is obtained as follows: The scheduler records the real-time queuing depth of all healthy computing nodes through a sliding window, counts the number of healthy computing nodes at the current moment to obtain the number of nodes, and sums the real-time queuing depths of all healthy computing nodes and divides the sum by the number of nodes to obtain the global average depth.
3. The big data AI computing power load balancing scheduling and management method according to claim 2, characterized in that: The actual jump step length is obtained as follows: The current queue depth is compared with the global average depth. If the current queue depth is less than or equal to the global average depth, the basic step size is 1. Otherwise, the basic step size is equal to the current queue depth divided by the global average depth, rounded down, and then 1. Then, the base step size is exponentially decayed and corrected using the current adaptive sensitivity coefficient and the historical step size memory variable to obtain the actual jump step size.
4. The big data AI computing power load balancing scheduling and management method according to claim 3, characterized in that: The specific method for the exponential decay correction is as follows: The base step size is multiplied by the adaptive sensitivity coefficient to obtain the sensitivity adjustment value. The historical step size memory variable is multiplied by the decay factor to obtain the memory decay value. The sensitivity adjustment value and the memory decay value are added together and rounded down, ensuring that the actual jump step size is at least 1.
5. The big data AI computing power load balancing scheduling and management method according to claim 4, characterized in that: The specific method for jumping backward this step length is as follows: The scheduler reads the index of the current pointer in the static node array, adds this index to the actual jump step size, and obtains a new index. If the new index is less than the length of the static node array, the pointer is moved directly to the node corresponding to the new index. If the new index is greater than or equal to the length of the static node array, the index is cyclically constrained according to the length of the static node array.
6. The big data AI computing power load balancing scheduling and management method according to claim 5, characterized in that: The method of applying cyclic constraints to the index based on the length of the static node array is as follows: The new index value is moduloed by the length of the static node array, so that the result falls within the valid index range of the static node array, thereby moving the pointer to the node corresponding to the modulo operation.
7. The big data AI computing power load balancing scheduling and management method according to claim 6, characterized in that: The adaptive sensitivity coefficient is updated in the following way: The adaptive sensitivity coefficient is updated by adjusting the queuing depth of the node before the jump to the global average depth and the size of the previous actual step size.
8. The big data AI computing power load balancing scheduling and management method according to claim 7, characterized in that: The update method for the historical step size memory variable is as follows: A preset memory update factor is used to multiply the actual jump step size by the memory update factor, thereby updating the historical step size memory variable.
9. The big data AI computing power load balancing scheduling and management method according to claim 8, characterized in that: The method of adjusting based on the comparison between the queuing depth of the node before the jump and the global average depth, as well as the size of the previous actual step size, is as follows: The sensitivity decay coefficient and sensitivity growth coefficient are preset. If the current node's queuing depth is greater than the global average depth and the previous actual step size is greater than 1, the adaptive sensitivity coefficient is multiplied by the sensitivity decay coefficient. Otherwise, if the current node's queuing depth is less than or equal to the global average depth and the previous actual step size was 1, then the adaptive sensitivity coefficient will be multiplied by the sensitivity growth coefficient.
10. A big data AI computing power load balancing scheduling and management system, used to implement the big data AI computing power load balancing scheduling and management method according to any one of claims 1-9, characterized in that, The big data AI computing power load balancing scheduling and management system includes: Initialization module: Arrange all healthy computing nodes in a static node array in a fixed order, initialize the global pointer to point to the first node, initialize the sliding window for calculating the arithmetic mean of the node queuing depth, and initialize the adaptive sensitivity coefficient and historical step size memory variable; Task receiving module: When a new computing task arrives at the scheduler, it triggers a scheduling decision; Load awareness module: Reads the current queuing depth of the node pointed to by the current pointer and obtains the current global average depth; The adaptive jump scheduling module calculates the basic step size based on the ratio of the current node's queuing depth to the global average depth. It then uses the adaptive sensitivity coefficient and historical step size memory variables to correct the actual jump step size. The module jumps backward by this step size and updates the historical step size memory variables and the adaptive sensitivity coefficient. This jump and update process is repeated until the first node with a queuing depth not exceeding the global average depth is found, and a new task is assigned. Pointer offset module: points the pointer to the next node after the node that assigned the task; if it exceeds the end of the array, it wraps around. Control and State Continuation Module: Waits for the next task to arrive, repeats the task receiving module to the pointer offset module, and periodically updates the global average depth; the updated adaptive sensitivity coefficient and historical step size memory variable are naturally carried over to the next scheduling without additional reset.