Dynamic computing power resource fragment integration system

Abstract

The application discloses a dynamic computing power resource fragmentation integration system and relates to the technical field of data resource management. The system comprises a mode selection module, a dual-mode implementation module, an anti-fragmentation punishment module and a rollback mechanism module. The mode selection module dynamically switches between a remaining capacity allocation mode and a fullness priority mode based on global utilization rate and large block loadable ratio. The dual-mode implementation module respectively executes resource allocation and task placement in the two modes. The anti-fragmentation punishment module eliminates candidate nodes that generate tail bits by simulating tail bit number and large block damage, and protects continuous resources. The rollback mechanism module handles special cases where all candidates generate tail bits, prevents infinite task queuing through hole filling tasks, minimum damage landing point selection and mode switching. The application effectively solves the problem of distributed computing power resource fragmentation, and improves resource utilization rate and throughput capacity.

Description

TECHNICAL FIELD

[0001] The present application relates to the technical field of data resource management, more particularly, the present application relates to a dynamic computing resource fragmentation integration system. BACKGROUND

[0002] With the development of cloud computing and artificial intelligence technology, more and more tasks need to occupy CPU cores, GPU memory, memory pages, network bandwidth and other computing resources on demand on shared physical hardware. When these resources are allocated according to multiple granularities and released after the task is completed, fragmentation problems will inevitably occur: a large number of small pieces of idle resources are left, which are independent and discontinuous, resulting in the inability to meet the needs of tasks that require large blocks of resources.

[0003] Traditional solutions include memory paging and segmentation mechanisms, fixed and variable size partitioning strategies, and compact migration. However, in distributed computing resources, these methods are often difficult to use directly: on the one hand, computing resources usually have multi-dimensional attributes, and simple paging will destroy the requirements of tasks for NUMA topology or data locality; on the other hand, migrating or compressing resource occupation often involves suspending or migrating tasks, which will bring huge performance jitter and overhead.

[0004] Therefore, a simple, scalable and interpretable fragmentation integration mechanism is needed to meet task performance and security isolation while avoiding the generation of unusable small pieces of debris and dynamically switching strategies during cluster load changes to balance low-latency services and large task throughput.

[0005] In view of the above problems, the present application provides a solution. SUMMARY

[0006] In order to overcome the above-mentioned defects of the prior art, the embodiments of the present application provide a dynamic computing resource fragmentation integration system to solve the problems raised in the background art.

[0007] To achieve the above object, the present application provides the following technical scheme:

[0008] The dynamic computing resource fragmentation integration system comprises a mode selection module, a dual-mode implementation module, a reverse fragmentation penalty module and a rollback mechanism module, and the modules are signal connected;

[0009] The mode selection module calculates the node utilization rate based on the remaining amount and total capacity of each node in the resource dimension set to obtain the global utilization rate, scans the maximum continuous resource block that can be allocated at one time based on the multi-dimensional demand of the head task in the queue to calculate the large block loadable ratio, and uses a joint criterion to select the remaining capacity allocation mode or the fill priority mode according to the preset high and low water level thresholds and the residence time.

[0010] The dual-mode implementation module separately implements the dual modes, sorts the task queue, selects a target node according to the allocation probability, and simulates placement, and fills the mode from the candidate node set to select a node with the most remaining resources and without tail debris after placing the task as a carrying node, continuously fills the task in the corresponding node, and forms a continuous resource block.

[0011] The anti-fragmentation penalty module simulates task placement and calculates tail debris and large block damage before actual placement, and if a candidate node will produce tail debris after placing the task, it is directly eliminated; otherwise, in the remaining capacity allocation mode, the node with the smallest large block damage and the most remaining resources is selected, and in the fill priority mode, the node with the smallest damage and the least remaining resources is selected.

[0012] The rollback mechanism module uses smaller tasks to fill holes when all candidate nodes may produce tail debris; if it is impossible to fill holes, the node with the smallest tail debris and large block damage is selected to land, and it is listed in the priority recycling list, and when the load is close to high and hole filling is impossible, the parameters are re-evaluated and switched to the fill priority mode.

[0013] In a preferred embodiment, the mode selection module includes the following steps:

[0014] For each node and dimension Calculate the utilization rate: , the remaining capacity of each node in each dimension is summarized to obtain the global utilization rate : ;

[0015] For each dimension of the head task and and according to the above two parameters : ;

[0016] Determine which resource allocation mode to use according to the two parameters and , the specific rules are as follows:

[0017] If and , enter the remaining capacity allocation mode;

[0018] If or , enter the fill priority mode;

[0019] In other cases, maintain the previous mode unchanged.

[0020] In a preferred embodiment, the dual-mode implementation module includes the following steps:

[0021] Enter the remaining capacity allocation mode:

[0022] Filtering candidate set S using capacity constraints, affinity, isolation, and link health, etc.

[0023] Normalizing total available resources of each candidate node as allocation probability;

[0024] Prioritizing by service level, then by arrival time, and then by bottleneck dimension demand;

[0025] Probability selection and placement attempt, then enter anti-fragmentation penalty check;

[0026] If eliminated, resample in candidate set S until passed or candidate set S is empty and turn into fallback processing.

[0027] Enter fill priority mode:

[0028] Bearing node selection: select the node b with the largest remaining amount in the candidate set S;

[0029] If there is no complete pass, take the node with the least tailings and the smallest damage as the least damage landing point;

[0030] Place subsequent tasks continuously to node b until one of the hard upper limit, tailings hole, or temperature, power consumption, and queue depth red line is triggered.

[0031] In a preferred embodiment, the anti-fragmentation penalty module includes the following steps:

[0032] Anti-fragmentation penalty and selection rules are:

[0033] Simulate placement and calculate tailings, if any dimension appears less than the minimum allocable granularity of the unusable leftovers, it is considered to produce tailings, and the candidate is directly eliminated;

[0034] Calculate the damage level of the large block as the descending order of the maximum continuous block before and after placement;

[0035] In the remaining capacity allocation mode, first sort by damage level from small to large, if parallel, sort by the total remaining amount after placement from large to small to take the optimal;

[0036] Candidates that reach the node soft upper limit are not used in the current round, and are included in the candidate set S in the next round.

[0037] In a preferred embodiment, the fallback mechanism module includes the following steps:

[0038] Tailings repair mechanism: when the node b has a remaining amount in a certain dimension in the minimum granularity threshold neighborhood, preferentially insert smaller or scalable tasks from the queue to fill the hole;

[0039] If patching the hole is not feasible, add b to the priority recycling list;

[0040] Loading and loop control are as follows: once a contiguous block of resources is passed, the task is loaded immediately;

[0041] After loading is complete, the current global utilization rate will be used as a basis. Compared to large-capacity load capacity The dwell time determines whether to maintain or switch modes, and the process returns to the mode selection module for repeated execution.

[0042] If tailings are generated after simulation, a rollback process is executed:

[0043] R1, first perform the double-hit combo to patch the hole, that is, find a small task that can be placed first to eliminate the tailings, and then retry the original placement;

[0044] If R1 is not feasible, then select the node with the least amount of debris and the least amount of large-scale damage from the candidates and force it to land, and mark that node as the priority for recovery;

[0045] If detecting global utilization The water level is approaching high or the load capacity of large blocks is high. If patching the hole is hopeless, the rollback mode selection module will re-evaluate and switch to the fill-first mode.

[0046] The technical effects and advantages of the dynamic computing resource fragment integration system of this invention are as follows:

[0047] The mode selection module dynamically switches modes based on global utilization and the large block load ratio. Under low load, tasks are distributed according to the remaining capacity to avoid node overheating and overload and reduce queuing delays for small tasks. Under high load, resources are prioritized to fill up and quickly form continuous large blocks of resources to meet the scheduling needs of large tasks.

[0048] Reduce fragmentation generation and improve resource utilization: The anti-fragmentation penalty module calculates the number of debris and large block damage by simulating placement, and directly eliminates candidate nodes that will generate unusable debris, while protecting continuous resources from being destroyed, reducing fragmentation from the source and improving the overall utilization of computing resources.

[0049] To address special circumstances and ensure task continuity: The rollback mechanism module handles extreme cases where all candidate nodes generate tails by filling the minimum damage node with the hole-filling task and selecting the rollback re-evaluation mode, thereby preventing tasks from queuing indefinitely and ensuring stable operation.

[0050] Simple and scalable, meeting security and performance requirements: The overall architecture is clear and highly interpretable, adaptable to the multi-dimensional attributes of distributed computing resources, and while meeting the requirements of task security isolation and performance, it also takes into account low-latency services and high task throughput, with strong scalability. Attached Figure Description

[0051] Fig. 1 This is a schematic diagram of the process structure of the dynamic computing power resource fragment integration system of the present invention.

[0052] Fig. 2 This is a schematic diagram of the dynamic computing power resource fragment integration system of the present invention. Detailed Implementation

[0053] 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.

[0054] Example: Please refer to Figs. 1-2 As shown, the present invention discloses a dynamic computing resource fragmentation integration system, including: a mode selection module, a dual-mode implementation module, an anti-fragmentation penalty module, and a rollback mechanism module, with signal connections between the modules;

[0055] The mode selection module obtains the remaining amount and total capacity of each node in the cluster across the resource dimension set, calculates the node utilization rate, and obtains the global utilization rate accordingly. Based on the multi-dimensional requirements of the task at the head of the queue, it scans the largest contiguous resource block that can be allocated at one time to calculate the large block load ratio. Based on preset high and low water level thresholds and residence time, it uses a joint criterion to select either the remaining capacity allocation mode or the fill-first mode.

[0056] The dual-mode implementation module provides the implementation for each of the two modes. It sorts the task queue and selects target nodes based on the amortized probability and simulates their placement. In the priority filling mode, it selects the node with the most remaining resources from the candidate node set and does not generate tails after placing tasks as the carrying node. Tasks are continuously filled into the corresponding node to form a continuous resource block.

[0057] The anti-fragmentation penalty module simulates task placement and calculates the number of debris and large block damage before actual placement. If a candidate node will generate debris after placing the task, it will be directly eliminated; otherwise, in the remaining capacity allocation mode, the node with the least large block damage and the most remaining resources is selected, and in the fill-priority mode, the node with the least damage and the least remaining resources is selected.

[0058] The rollback mechanism module prioritizes filling holes with smaller tasks when all candidate nodes are likely to generate debris. If filling holes is not possible, the node with the fewest debris and the smallest large-scale damage is selected for landing and added to the priority recycling list. When the load is close to high and filling holes is hopeless, the parameters are re-evaluated and the module switches to the fill-priority mode.

[0059] In the mode selection module, the remaining amount and total capacity of each node in the cluster are obtained in the resource dimension set to calculate the node utilization rate and thus obtain the global utilization rate. Based on the multi-dimensional requirements of the task at the head of the queue, the largest contiguous resource block that can be allocated at one time is scanned to calculate the large block loading ratio. According to preset high and low water level thresholds and residence time, a joint criterion is used to select the mode of allocating by remaining capacity or the mode of filling first. The specific content includes:

[0060] A single computing resource cluster simultaneously handles small online inference tasks and large batch processing tasks. Under low load, it is desirable to distribute the resources evenly, while under high load or when there are no large, continuous empty slots, it is desirable to fill them all at once to free up the entire resource for large tasks as quickly as possible. The switching between these two modes is based on global utilization. Compared to large-capacity load capacity The joint criteria;

[0061] Real-time calculation of global utilization This refers to the ratio of the remaining amount of each resource dimension on each node of the cluster to the total capacity.

[0062] Node utilization rate is the number of nodes In dimensions The utilization rate is defined as: The more resources a node has available, the lower its utilization rate.

[0063] Global utilization To reflect the overall cluster load, the global average utilization rate is defined as the difference between the sum of the remaining resources of each node in each dimension and the total capacity. The formula is as follows: ;

[0064] Simultaneously calculate the large block loadability ratio , which is the ratio of the current head task's demand for each critical resource dimension in the queue to the largest contiguous block that can be allocated at once, is defined as the minimum value among the ratios of the largest contiguous resource block that can be allocated across all critical resource dimensions to the demand of the head task. Among them, the largest contiguous allocatable block To find the maximum contiguous amount of resources that can be allocated to a single task at once by scanning currently unoccupied or soon-to-be-released resource blocks along dimension k; the task at the head of the queue requires... The task queue is formed in order according to queuing rules, with the task at the head of the queue being the first task currently waiting to be scheduled. This indicates the amount of resources required for the task in dimension k. For tasks with high multidimensional resource requirements, Larger in some dimensions;

[0065] like This indicates that there are at least some nodes with enough continuous resources to accommodate the first task in the queue;

[0066] like If the task cannot be loaded, fragment reshaping is required;

[0067] Based on these two parameters and preset high and low thresholds, it is determined whether the load is low or high, and whether there are enough continuous resources available to load large tasks.

[0068] Based on two parameters and The specific rules for determining which resource allocation mode to use are as follows: If and This indicates that the global load is low and there is a sufficiently large block space, so it enters the mode of allocating the remaining capacity.

[0069] like or This indicates that the global utilization rate is close to or exceeds the high water level, or the current maximum consecutive empty space is insufficient to accommodate the task at the front of the queue, and enters the fill priority mode;

[0070] In other cases, maintain the previous pattern unless the dwell time is reached and a reassessment is required. Setting a dwell time can prevent rapid oscillations, especially in situations where... The switching phenomenon that may occur when approaching the threshold.

[0071] In the dual-mode implementation module, the implementation corresponding to each mode is given. The task queue is sorted and the target node is selected and placed according to the amortized probability. In the priority filling mode, the node with the most remaining resources and which will not generate tails after placing tasks is selected from the candidate node set as the carrying node. Tasks are continuously filled into the corresponding node to form a continuous resource block. The specific content includes:

[0072] The resource allocation based on remaining capacity is suitable for situations with low load and abundant large blocks of resources. First, a set of candidate nodes S is selected, and the available resource ratio of each candidate node is calculated. As a distributed probability;

[0073] Tasks are sorted according to service level urgency, arrival time, and resource bottleneck requirements, and then retrieved from the queue sequentially based on probability. The target node is selected using a roulette wheel method. After selection, an anti-fragmentation penalty check must be performed; otherwise, placement will result in a granularity smaller than the minimum allocatable granularity. If the node produces excessive tailings, it is rejected and a new candidate is selected. A soft cap is set on the utilization of a single node. If the value exceeds this threshold, the node will be temporarily skipped to avoid hotspots.

[0074] In the remaining capacity allocation mode, the goal is to distribute tasks as evenly as possible across nodes while ensuring resource availability, avoiding overheating or overload on some nodes, and reducing task queuing latency. This mode is suitable for scenarios with low overall cluster load, ample resources, and the need to serve multiple small tasks or online inference tasks. The following steps detail the operation of the remaining capacity allocation mode:

[0075] Candidate node selection: Based on task requirements, a candidate set S is selected using conditions such as capacity constraints, affinity, isolation, and link health. Only nodes that meet all constraints can be considered as candidates to avoid task failure due to security or topology mismatch after actual placement.

[0076] Calculate the sharing ratio: for each candidate node The formula for calculating the total amount of available resources is as follows: Then calculate the amortized probability: , It only reflects the remaining resource ratio of the node;

[0077] Task queue sorting: The task queue is sorted according to the urgency of the service level, with urgent tasks taking priority; if the urgency is the same, it is served on a first-come, first-served basis according to arrival time; if still the same, it can be sorted from largest to smallest according to a bottleneck resource dimension to ensure that large tasks that cannot be accommodated will not be kept at the end of the queue for a long time. This sorting rule does not increase or decrease the number of criteria.

[0078] Roulette allocation and anti-fragmentation check: Retrieve tasks from the head of the task queue Using the roulette wheel method or random sampling method based on the allocated probability Select a target node Then, an anti-fragmentation penalty check is performed: the simulation places the task onto the node. Calculate the number of tailings Large-scale damage .

[0079] like This indicates that placing it will result in unusable bits, so the node should be discarded and removed from the list. Remove from the list. Repeat the roulette wheel selection process to check new nodes until a matching node is found. If none of the candidates meet the requirements, the node will enter the special handling of the fallback mechanism module.

[0080] like Then compare the possible contiguous block losses. In the remaining capacity allocation mode, this invention prioritizes selection based on lexicographical order. The smallest node;

[0081] like If they are the same, then select the remaining total amount after placement. Larger nodes are used to maintain available space for subsequent tasks;

[0082] Single-node soft cap control: When the actual utilization rate of a node... Reaching the soft limit If a node is not considered in the next round, it will be temporarily ignored to avoid a few nodes overheating or the queue depth being too high. Nodes that have reached the soft limit will re-enter the candidate set in the next round.

[0083] The fill-first mode is suitable for situations with high load or insufficient current maximum consecutive empty slots to accommodate the largest task at the front of the queue. It selects a node b from the candidate set, that is, the node with the largest remaining available space and which has passed the anti-fragmentation check, and assigns subsequent tasks to this node as consecutively as possible until the hard limit is reached. Or, if it is placed again, it will generate tails, or the node temperature / power consumption will reach the red line, etc.

[0084] If filling the blocks creates a series of large blocks that satisfy the requirements of the first task, then... If so, immediately assign the first major task to the queue and repeat the process until the load drops and the switching conditions are met;

[0085] When in fill-first mode, the goal is to quickly and centrally fill the corresponding nodes, allowing idle resources to be consolidated into large contiguous blocks. This enables the loading of large tasks in the queue, which is useful when the cluster load is high or the current largest available contiguous block is insufficient to accommodate the large task at the head of the queue. The specific steps are as follows:

[0086] Selecting a host node: Choose a node from the candidate set S as the current host node b. The selection principle is: prioritize the node with the largest remaining resources, and ensure that placing tasks on this node will not generate trailing debris. If there is no such condition For nodes with the most tailings, select the number of tailings. Minimal and large-area damage The smallest node;

[0087] Continuous filling: at the bearing node Continue placing subsequent tasks until one of the following three conditions is met:

[0088] Condition 1: Node utilization reaches the hard cap. ;

[0089] Condition two: Re-placement will leave unusable debris and will not be able to be crossed by patching the hole. ;

[0090] Condition 3: The node temperature or power consumption triggers the safety red line, or the waiting queue backlog exceeds the threshold.

[0091] Trace repair: If after placing several tasks, the node Residual amount in a certain dimension Falling If the range is insufficient, try inserting small or scalable tasks to fill the gaps, increasing the remaining capacity to no less than [amount missing]. If patching the hole is not feasible, stop filling the hole at that node immediately, mark it as a priority for recycling, and wait for subsequent smaller tasks to fill the hole;

[0092] Loading large tasks: Once a contiguous block of resources that satisfies the requirements of the task at the head of the queue is formed by filling one or more nodes, i.e. Immediately load the top task of the queue onto the most suitable node or a combination of nodes. At this point, affinity rules can be used to select the optimal node for that task.

[0093] Looping and Mode Switching: After filling is complete, select the next carrying node and repeat the above steps until all large tasks in the queue are scheduled, or Dropped below and When the switching conditions are met and the dwell time is reached, the system can switch back to the remaining capacity allocation mode.

[0094] In the anti-fragmentation penalty module, before actual placement, task placement is simulated and the number of debris and large block damage are calculated. If a candidate node will generate debris after task placement, it is directly eliminated; otherwise, in the remaining capacity allocation mode, the node with the least large block damage and the most remaining resources is selected, and in the fill-priority mode, the node with the least damage and the fewest remaining resources is selected. Specific details include:

[0095] In either of the two modes described above, before placing the task on the candidate node, the placement result is simulated and two key metrics are calculated: the number of tails. Large-scale damage The number of tails represents the number of resources left behind after placement that is less than [a certain value]. Unusable fractional quantities, if If so, the candidate node will be eliminated directly;

[0096] If all candidates exhibit tailings, they undergo special treatment. Large-scale damage indicates the degree of decrease in the maximum consecutive vacancy ratio after placement, used for cases where... Lexicographical comparison of candidates: In the remaining capacity allocation mode, priority is given to those with less damage and more remaining resources after placement;

[0097] In the fill-priority mode, prioritize those that cause less damage and have fewer remaining resources after placement;

[0098] Anti-fragmentation penalty avoids generating unusable small debris during task placement decisions, while minimizing damage to large contiguous resources. The implementation steps are as follows:

[0099] Simulated placement: for the task to be placed and candidate nodes First, simulate the remaining resources after placing the task. and the largest contiguous allocatable block Simulations can be performed at the scheduling level without affecting the actual execution of tasks.

[0100] Calculate the number of tailings : Inspect each resource dimension ,like Then it is recorded as a tail, and the sum of all dimensions is obtained. ,if If the placement scheme produces unusable bits, then the candidate node is directly eliminated. If all candidates... Then it will be handled by the rollback mechanism module.

[0101] Calculate large block damage For each resource dimension, compare the change in the maximum contiguous block size before and after placement. Use the formula... The larger the number of loss steps, the more severe the damage to continuous resources caused by the placement.

[0102] Lexicographical selection: when multiple candidate nodes satisfy... At that time, different selection rules are used depending on the mode:

[0103] Allocation based on remaining capacity: By Sort by size from smallest to largest; if they are the same, sort by the total amount of resources remaining after placement. Sort the nodes from largest to smallest and select the nodes with the least damage and the most remaining nodes.

[0104] Fill priority mode: Press Sort the nodes from smallest to largest. If they are the same, sort them from smallest to largest by the total amount of resources remaining after placement. Select the nodes with the least damage and the least remaining resources so that they can be filled quickly.

[0105] Hard filtering and sorting ensure that placement does not produce fragmentation and protects continuous large blocks.

[0106] In the rollback mechanism module, when all candidate nodes are likely to generate debris, smaller-sized tasks are prioritized for filling the gaps. If filling the gaps is not possible, the node with the fewest debris and the smallest large-scale damage is selected for deployment and added to the priority recycling list. When approaching high load and filling the gaps is hopeless, the parameters are re-evaluated and the system switches to a fill-priority mode. Specific details include:

[0107] Special case handling and rollback mechanism: When all candidate nodes produce unusable trailing debris after simulation placement, i.e. In this case, prioritize checking if there are any available small tasks to fill the tail and allow the remaining crossover. ;

[0108] If it exists, place the sub-task first, then place the target task;

[0109] If it does not exist, select the node with the least amount of debris and the least amount of large-scale damage from all candidates and place it there, marking it as a priority for recycling to wait for subsequent small tasks to fill it;

[0110] In addition, in extreme cases, a rollback can be chosen to reassess the overall utilization rate. Compared to large-capacity load capacity ;

[0111] If the load is already close to the high water level or If the task is not completed, it will switch to the fill-first mode to focus on fragment shaping. Even when all candidate nodes generate tails, it can still provide a reasonable placement plan or quickly shape resources by switching modes, thereby ensuring that tasks do not queue up indefinitely.

[0112] In actual scheduling, situations may arise where trailing debris is generated after all candidate nodes are placed. To prevent task starvation or entering an unsolvable state, the following handling and rollback mechanism is implemented:

[0113] A two-pronged approach to patching gaps: First, check the task queue for tasks that are small enough or scalable. These can be prioritized and placed on certain nodes to fill the tails, allowing the remaining resources on these nodes to be utilized. If such a task exists, first place the hole-filling task, then replace the original task to ensure that no tailings are generated. This is especially effective in high-concurrency small task scenarios, where scattered small tasks can be used to fill the holes.

[0114] Minimum damage landing point: If no available hole-filling task exists, select the number of debris from all candidate nodes. Minimal and large-scale damage The smallest node is placed and added to the priority recycling list so that when a small task arrives later, the remaining space of the node is filled first, minimizing the impact of fragmentation and leaving room for future patching.

[0115] Rollback mode or reassessment: If detected Approaching high water level or If patching the hole is hopeless, you can roll back the selected steps and reassess the overall utilization. Compared to large-capacity load capacity The parameters are then switched to fill-priority mode to focus on fragment reshaping.

[0116] For example, if the overall utilization rate has reached 0.85 at a certain moment, but it is still in the mode of allocating according to the remaining capacity and there are no candidate nodes that can accept tasks, then the rollback mode is evaluated and switched to the fill-first mode. By filling and recycling, continuous resources are quickly released to ensure stable operation even under special circumstances.

[0117] The above formulas are all dimensionless calculations. The formulas are derived from software simulations based on a large amount of collected data to obtain the most recent real-world results. The preset parameters in the formulas are set by those skilled in the art according to the actual situation.

[0118] The above embodiments can be implemented, in whole or in part, by software, hardware, firmware, or any other combination thereof. When implemented using software, the above embodiments can be implemented, in whole or in part, in the form of a computer program product.

[0119] Those skilled in the art will recognize that the modules and algorithm steps of the various examples described in conjunction with the embodiments disclosed herein can be implemented in electronic hardware, or a combination of computer software and electronic hardware. Whether these functions are implemented in hardware or software depends on the specific application and inventive constraints of the technical solution. Those skilled in the art can use different methods to implement the described functions for each specific application, but such implementation should not be considered beyond the scope of this application.

[0120] In addition, the functional modules in the various embodiments of this application can be integrated into one processing module, or each module can exist physically separately, or two or more modules can be integrated into one module.

[0121] The above description is merely a specific embodiment of this application, but the scope of protection of this application is not limited thereto. Any variations or substitutions that can be easily conceived by those skilled in the art within the scope of the technology disclosed in this application should be included within the scope of protection of this application. Therefore, the scope of protection of this application should be determined by the scope of the claims.

[0122] In conclusion, the above description is only a preferred embodiment of the present invention and is not intended to limit the present invention. Any modifications, equivalent substitutions, improvements, etc., made within the spirit and principles of the present invention should be included within the protection scope of the present invention.

Claims

1. A dynamic computing resource fragmentation integration system, characterized in that, include: The module includes a mode selection module, a dual-mode implementation module, an anti-fragmentation penalty module, and a rollback mechanism module, with signal connections between each module. The mode selection module obtains the remaining amount and total capacity of each node in the cluster across the resource dimension set, calculates the node utilization rate, and obtains the global utilization rate accordingly. Based on the multi-dimensional requirements of the task at the head of the queue, it scans the largest contiguous resource block that can be allocated at one time to calculate the large block load ratio. Based on preset high and low water level thresholds and residence time, it uses a joint criterion to select either the remaining capacity allocation mode or the fill-first mode. The dual-mode implementation module provides the implementation for each of the two modes. It sorts the task queue and selects target nodes based on the amortized probability and simulates their placement. In the fill-priority mode, it selects the node with the most remaining resources from the candidate node set and does not generate tails after placing tasks as the carrying node. Tasks are continuously filled into the corresponding node to form a continuous resource block. The anti-fragmentation penalty module simulates task placement and calculates the number of debris and large block damage before actual placement. If a candidate node will generate debris after placing the task, it will be directly eliminated; otherwise, in the remaining capacity allocation mode, the node with the least large block damage and the most remaining resources is selected, and in the fill-priority mode, the node with the least damage and the least remaining resources is selected. The rollback mechanism module prioritizes filling holes with smaller tasks when all candidate nodes are likely to generate debris. If filling holes is not possible, the node with the fewest debris and the smallest large-scale damage is selected for landing and added to the priority recycling list. When the load is close to high and filling holes is hopeless, the parameters are re-evaluated and the module switches to the fill-priority mode.

2. The dynamic computing resource fragmentation integration system according to claim 1, characterized in that, compute nodes In dimensions Node utilization : The global utilization rate is obtained by summing the remaining capacity and capacity of each node in each dimension. : ; Count the maximum contiguous allocable block for the first task of the queue in each dimension. Team leader's mission requirements And based on this, the large-scale loading ratio is obtained. : .

3. The dynamic computing resource fragmentation integration system according to claim 2, characterized in that, Based on two parameters and The specific rules for determining which resource allocation mode to use are as follows: like and Enter the remaining capacity allocation mode; like or Enter fill-priority mode; In other cases, the previous pattern remains unchanged.

4. The dynamic computing resource fragmentation integration system according to claim 1, characterized in that, To enter the allocation mode based on remaining capacity: Candidate set S is selected using capacity constraints, affinity, isolation, and link health conditions; The allocation probability is normalized to the total available resources of each candidate node. Prioritize by service level, then sort by arrival time for the same service level, and finally sort by bottleneck dimension demand. If a probability-based point is selected and placed, an anti-fragmentation penalty check is initiated. If eliminated, resampling is performed within the candidate set S until it passes or the candidate set S becomes empty, in which case a fallback process begins.

5. The dynamic computing resource fragmentation integration system according to claim 4, characterized in that... Entering the fill-priority mode is as follows: Node selection: Select node b with the largest remaining quantity from the candidate set S; If no one passes through completely, the node with the least amount of tail debris and the least damage is taken as the minimum damage landing point. Subsequent tasks will be continuously deployed to node b until the hard limit is triggered, the tail cannot be patched, or one of the red lines of temperature, power consumption, or queuing depth is reached.

6. The dynamic computing resource fragmentation integration system according to claim 1, characterized in that, The anti-fragmentation penalty and selection rules are as follows: Simulate placement and calculate the number of tails. If any dimension has an unusable zero that is smaller than the minimum allocatable granularity, it is considered that tails have been generated, and the candidate node is directly eliminated. The damage level of the large block is calculated as the descent order of the largest continuous block before and after placement; In the remaining capacity allocation mode, first sort by damage level from smallest to largest; if they are tied, sort by the remaining total amount after placement from largest to smallest and select the optimal one. Candidate nodes that have reached the soft upper limit of nodes will not be used in the current round, but will be included in the candidate set S in the next round.

7. The dynamic computing resource fragmentation integration system according to claim 1, characterized in that, The tail chip repair mechanism is as follows: When node b has a remaining quantity in a certain dimension that is in the neighborhood of the minimum granularity threshold, smaller or scalable tasks are preferentially inserted from the queue to fill the gaps. If patching the hole is not feasible, then add b to the priority recycling list.

8. The dynamic computing resource fragmentation integration system according to claim 7, characterized in that, Loading and cycle control are as follows: For tasks that match consecutive resource blocks, load them immediately; After loading is complete, the current global utilization rate will be used as a basis. Compared to large-capacity load capacity The mode is maintained or switched based on the dwell time, and the process returns to the mode selection module for repeated execution.

9. The dynamic computing resource fragmentation integration system according to claim 7, characterized in that, If tailings are generated after simulation, a rollback process is executed: R1, first perform the double-hit combo to patch the hole, that is, find a small task that can be placed first to eliminate the tailings, and then retry the original placement; If R1 is not feasible, then select the node with the least amount of debris and the least amount of large-scale damage from the candidate nodes and force it to land, and mark that node as the priority for recycling. If detecting global utilization The water level is approaching high or the load capacity of large blocks is high. If patching the hole is hopeless, the rollback mode selection module will re-evaluate and switch to the fill-first mode.

Images