A resource scheduling method for cloud rendering clusters based on AI distributed deployment

Abstract

This invention provides a resource scheduling method for cloud rendering clusters based on AI distributed deployment. First, the original instruction stream is divided into instruction particles carrying energy consumption labels, latency labels, and complementarity weights. A cross-task instruction resonance graph is constructed to locate complementary candidate resonance particle groups. Placeholder particles are generated based on time-series prediction to fill upcoming instruction stream gaps. Particles are exchanged and spliced ​​across GPUs in a dynamic splicing network, solidifying into a continuous target instruction stream across GPUs. Simultaneously, real-time power consumption and performance indicators are collected, and a joint performance-energy consumption evaluation is performed on multiple candidate splicing schemes to select and apply the optimal scheme. Without compromising business correctness, this invention significantly improves GPU execution unit utilization, reduces end-to-end latency, and lowers energy consumption through continuous pipeline, zero-copy data reuse, and rollback anchor point guarantees. It is suitable for large-scale parallel scenarios such as film and television rendering, cloud gaming, and digital twins.

Description

Technical Field

[0001] This invention relates to the field of cloud rendering and distributed GPU resource scheduling technology, and in particular to a cloud rendering cluster resource scheduling method based on AI distributed deployment. Background Technology

[0002] As cloud rendering clusters continue to expand in scale, GPUs have become the core hardware resource supporting graphics rendering, AI inference, and massively parallel computing. In existing technologies, cloud rendering task scheduling primarily focuses on the task-level or thread-level, improving the overall computing power utilization of the cluster through task allocation, load balancing, or priority control.

[0003] However, in practical applications, due to the differences in instruction structure and execution timing among different types of rendering tasks (such as ray tracing, geometry calculation, and AI denoising), the instruction pipeline inside the GPU often experiences discontinuous execution segments and idle hardware execution units, resulting in so-called "instruction-level fragmentation." This problem is particularly prominent in multi-task parallel scenarios. Even if the overall computing power of the cluster is sufficient, the effective utilization rate of GPU units remains at a low level for a long time, leading to increased rendering latency and energy waste. Therefore, we propose a cloud rendering cluster resource scheduling method based on AI distributed deployment. Summary of the Invention

[0004] The purpose of this invention is to address the shortcomings of existing technologies by providing a cloud rendering cluster resource scheduling method based on AI distributed deployment, thereby solving the technical problems mentioned in the background section.

[0005] To achieve the above objectives, the present invention provides the following technical solution:

[0006] A cloud rendering cluster resource scheduling method based on AI distributed deployment includes the following steps:

[0007] S1. Divide the instruction stream of each GPU execution unit in the distributed GPU cluster into multiple instruction particles, each instruction particle carrying an energy consumption label, a latency label, and a complementarity weight;

[0008] S2. Use an artificial intelligence model to construct a cross-task instruction resonance graph, perform complementarity detection on instruction particles in different rendering tasks, and identify instruction particle groups that can resonate in the time dimension.

[0009] S3. Based on the timing prediction model, predict possible gaps in the instruction stream during future execution, generate placeholder particles, and insert the placeholder particles into the instruction stream to reduce instruction execution latency.

[0010] S4. Instruction particles are exchanged between different GPUs through a dynamic splicing network, and the instruction particles are spliced ​​according to complementarity to form a continuous instruction stream across GPUs;

[0011] S5. During the process of splicing the commanded particles, calculate the performance indicators and energy consumption costs of different splicing schemes, and select the target splicing scheme that maximizes performance and minimizes energy consumption.

[0012] S6. Based on real-time feedback data from GPU execution, update the instruction splicing strategy of the artificial intelligence model to form an evolvable adaptive scheduling mechanism.

[0013] Furthermore, S1 specifically involves: obtaining the raw instruction stream of each GPU execution unit in the distributed GPU cluster, wherein the instruction stream includes ray tracing instructions, geometric calculation instructions, and AI noise reduction instructions; dividing the raw instruction stream into multiple fine-grained instruction units according to the execution boundary and defining them as instruction particles; and attaching an energy consumption label, a latency label, and a complementarity weight to each instruction particle to characterize the power consumption level, execution time, and complementarity with other instruction particles during the execution process.

[0014] Furthermore, S2 specifically involves: based on the instruction particles obtained in S1, constructing a cross-task particle set, and uniformly storing instruction particles from different rendering tasks in a shared space; using an artificial intelligence model to perform feature comparison on the particle set, analyzing the energy consumption label, latency label, and complementarity weight of each instruction particle; based on the comparison results, establishing an instruction resonance graph, and identifying instruction particle groups that can complementaryly fill temporal gaps in the graph structure; and selecting instruction particle groups with resonance degree greater than a preset threshold in the instruction resonance graph as candidate objects for subsequent splicing.

[0015] Furthermore, S3 specifically involves: monitoring the execution status of the GPU instruction pipeline and obtaining upcoming timing gaps in real time; using a timing prediction model to predict the location and duration of instruction stream gaps that may occur within a preset time period in the future; generating placeholder particles with low latency and low energy consumption at the predicted gap locations; and inserting the placeholder particles into the splicing sequence of the candidate instruction particle group to fill instruction stream gaps in advance.

[0016] Furthermore, S4 specifically involves: establishing a dynamic splicing network between GPUs in a distributed cluster environment for exchanging candidate instruction particles between different GPUs; performing complementary matching on candidate instruction particles from different GPUs in the dynamic splicing network; performing splicing operations on instruction particles based on the matching results to form a continuous target instruction stream across GPUs; and distributing the target instruction stream to the corresponding GPU execution units for parallel execution.

[0017] Furthermore, S5 specifically involves: during the formation of the target instruction stream, collecting real-time power consumption data and execution performance indicators of the GPU execution unit; using an AI model to comprehensively evaluate the performance indicators and energy consumption costs of different splicing schemes; selecting the splicing scheme with a large performance improvement and a small increase in energy consumption as the final scheme from the evaluation results; and applying the final scheme to the GPU instruction stream execution to achieve a dual optimization effect of performance and energy consumption.

[0018] Furthermore, S6 specifically involves: storing the performance feedback data and energy consumption feedback data obtained during GPU execution as a scheduling log; using the scheduling log to train an artificial intelligence model and update the resonance features and splicing strategy of instruction particles; and generating an optimized instruction splicing scheme based on the updated model when a new task arrives. The process of S1-S5 is repeated, continuously iterating and updating the splicing mechanism to form an adaptively evolving scheduler.

[0019] The beneficial effects of this invention are as follows:

[0020] This invention transforms the GPU instruction pipeline from discrete to continuous through a continuous link of "instruction particleization → cross-task instruction resonance → gap prediction and occupancy → cross-GPU dynamic splicing," avoiding idle hardware execution units and solving the bottleneck of "low utilization and increased latency caused by instruction-level fragmentation." It eliminates GPU "instruction-level fragmentation" at its root, improves utilization, and reduces end-to-end latency.

[0021] By generating "placeholder particles" based on time-series prediction and actively filling the gaps in the instruction stream before splicing the existing candidate resonant particle group, the GPU can switch from "passively waiting for tasks" to "actively placing places," compressing short-term gaps and queuing, thereby further reducing execution latency. Forward-looking placement and gap filling compress short-term gaps and reduce queue waiting.

[0022] In a dynamic splicing network, instruction particles are exchanged and spliced ​​according to complementarity, solidified into a continuous instruction stream across GPUs, which improves parallelism and pipeline utilization at the cluster scale, breaks through the limitations of single-card resources and instantaneous bandwidth, and forms a continuous instruction stream across devices by dynamically splicing across GPU particles, thus breaking through the bottleneck of single cards.

[0023] The performance indicators and energy consumption costs of multiple candidate solutions are evaluated simultaneously during the splicing process. The optimal solution that maximizes performance and minimizes energy consumption is selected and implemented. In the application phase, the goal of "dual optimization of performance and energy consumption" is achieved. Attached Figure Description

[0024] Figure 1 This is a schematic diagram of a cloud rendering cluster resource scheduling method based on AI distributed deployment according to the present invention. Detailed Implementation

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

[0026] Example 1: As Figure 1 As shown, this embodiment provides a cloud rendering cluster resource scheduling method based on AI distributed deployment, including the following steps:

[0027] S1. Divide the instruction stream of each GPU execution unit in the distributed GPU cluster into multiple instruction particles, each instruction particle carrying an energy consumption label, a latency label, and a complementarity weight;

[0028] S2. Use an artificial intelligence model to construct a cross-task instruction resonance graph, perform complementarity detection on instruction particles in different rendering tasks, and identify instruction particle groups that can resonate in the time dimension.

[0029] S3. Based on the timing prediction model, predict possible gaps in the instruction stream during future execution, generate placeholder particles, and insert the placeholder particles into the instruction stream to reduce instruction execution latency.

[0030] S4. Instruction particles are exchanged between different GPUs through a dynamic splicing network, and the instruction particles are spliced ​​according to complementarity to form a continuous instruction stream across GPUs;

[0031] S5. During the process of splicing the commanded particles, calculate the performance indicators and energy consumption costs of different splicing schemes, and select the target splicing scheme that maximizes performance and minimizes energy consumption.

[0032] S6. Based on real-time feedback data from GPU execution, update the instruction splicing strategy of the artificial intelligence model to form an evolvable adaptive scheduling mechanism.

[0033] S1. Divide the instruction stream of each GPU execution unit in the distributed GPU cluster into multiple instruction particles, each instruction particle carrying an energy consumption label, a latency label, and a complementarity weight; specifically including the following sub-steps:

[0034] S110: Acquisition of Raw Instruction Stream: In a distributed GPU cluster, the raw instruction stream is acquired through an instruction stream tracing agent. The acquired events include kernel startup, thread issuance, memory read / write, and texture sampling. A unified clock reference is used for time synchronization to ensure the timing consistency of events across nodes. When some events are lost, interpolation correction or placeholder padding methods are used to fill the gaps, ensuring data continuity and integrity. Acquisition frequency: Typically, sampling is performed once every 1ms, which can be adjusted to the microsecond level depending on hardware conditions. Implementation tool reference: The tracing agent can call commonly used GPU performance analysis interfaces in this field, such as NVIDIA CUPTI.

[0035] Data structure example:

[0036]

[0037] S120: Instruction Particle Division: In the acquired raw instruction stream, the instruction stream is divided into multiple fine-grained instruction units based on execution boundaries (such as kernel startup, synchronization points, and sudden changes in resource usage), which are defined as "instruction particles".

[0038] Granularity range: The minimum granularity is no less than 10 instructions, and the maximum continuous execution time is no more than 1ms. Dominant type determination criteria: If a certain type of instruction accounts for ≥60% of the particles, it is considered the dominant type.

[0039] Particle types and determination rules: Ray path particles: Ray interaction command ratio ≥ 70%; Geometric calculation particles: Triangle subdivision / matrix operation command ratio ≥ 60%; Texture sampling particles: Texture loading command ratio ≥ 50%;

[0040] Interpolation correction formula: If missing data occurs, the following formula can be used:

[0041]

[0042] in For missing indicators, These are the corresponding index values ​​of adjacent particles. The missing value is replaced by the average of the two valid values ​​before and after the missing point. This is the most basic and commonly used interpolation method, which can ensure data continuity and is simple to calculate.

[0043] Data structure example:

[0044]

[0045] S130: Tag Attachment and Feature Solidification: After particle partitioning, energy consumption tags, time delay tags, and complementarity weights are attached to each particle and solidified and stored in a unified format to ensure that they can be compared and reused in subsequent steps.

[0046] Energy consumption label calculation:

[0047]

[0048] The above formula uses the power consumption per unit time to indicate the energy consumption level of a particle. This indicates the power consumption of the GPU when executing this particle; The duration of the particle's life from start to finish; The power consumption is derived from the GPU sensor or the manufacturer's power AP. If the power consumption is constant, the shorter the execution time, the higher the energy consumption label value per unit time, indicating more intensive energy consumption behavior. Typical classification ranges: L1: <50W; L2: 50-150W; L3: >150W.

[0049] Delay label calculation:

[0050]

[0051] The above formula indicates that the total delay equals the sum of the waiting time and the execution time; This indicates the time a task needs to wait for scheduling or be queued. This indicates the actual execution time of the task on the GPU; this label comprehensively reflects the latency characteristics of the particles, taking into account both scheduling wait and computation execution; typical hierarchical intervals: L1: <1 ms; L2: 1-5 ms; L3: >5 ms; Complementary weight calculation:

[0052]

[0053] The above formula calculates the complementarity weight based on the reciprocals of memory utilization and bandwidth utilization, which is used to measure the complementarity of resource utilization. It represents the video memory usage rate (0-1). It represents bandwidth utilization (0–1). , This is an empirical weighting factor, which can be selected based on different hardware characteristics (e.g., default value). , (0.5); when the memory usage of a certain particle is low, A larger value makes the particle more "complementary" during matching; when a particle occupies less bandwidth, With a larger value, it can similarly complement high-bandwidth particles. In distributed GPU task stitching, This is used to prioritize highly complementary particle pairs, thereby balancing resource utilization. Example data structure:

[0054]

[0055] To elaborate: : Measures the intensity of particle energy consumption; : Measures the time delay characteristics of particles; : Measures the complementarity between particles in terms of video memory / bandwidth.

[0056] S2. Construct a cross-task instruction resonance graph using an artificial intelligence model, perform complementarity detection on instruction particles in different rendering tasks, and identify instruction particle groups that can resonate in the time dimension; specifically including the following sub-steps:

[0057] S210: Constructing a cross-task instruction particle set: In a distributed GPU cluster, instruction particles from different rendering tasks are uniformly stored in a shared space, forming a cross-task particle set; Time alignment: Using a unified clock reference, the instruction streams of different tasks are divided into fixed time windows (typically 10-50ms), and particle normalization is performed within the same window; Task identification: Each particle is assigned a Task_ID to distinguish the task origin; Consistency check: When the particle tags (energy consumption, latency) of different tasks differ too much, they are not included in the candidate set. The determination formula is:

[0058]

[0059] It is the tag value of particle i (e.g., energy consumption tag or time delay tag). This is the label value of particle j. The formula above is the consistency check condition, used to judge the two label values. and Are they close enough? If the relative difference between them does not exceed 10%, they are considered consistent and at the same level, thus eligible for further analysis. Data structure example:

[0060]

[0061] S220: Feature Comparison and Complementarity Analysis Based on Artificial Intelligence Model: Based on a unified set, an artificial intelligence model is used to compare the features of instruction particles, identify particle pairs with complementarity, and calculate the complementarity score.

[0062] Input features: energy consumption label, latency label, memory usage, bandwidth usage, execution start and end time, totaling 4-6 dimensions. Training sample source: from historical scheduling logs, covering 10 typical rendering tasks. 4 More than one pair of particles; complementarity scoring formula:

[0063]

[0064] in: This is the normalized value for energy consumption difference; the range is 0–1, and the smaller the value, the closer the energy consumption of the two particles is. This is the normalized value for the time delay difference; the range is 0–1, and the smaller the value, the closer the time delays of the two particles are. Resource overlap (0–1) indicates the degree of competition between two particles for video memory or bandwidth. A higher value indicates more severe resource overlap. , It is a weighting factor used to adjust the importance of the three parts in the score; typical values ​​are... It is 0.4. It is 0.3. It is 0.3;

[0065] Energy consumption dimension: The smaller the difference in energy consumption, the greater the contribution of this factor. Latency dimension: The smaller the latency difference, the greater the contribution. Resource complementarity dimension: The less resource overlap, the greater the contribution. Weighted summation yields... The closer the value is to 1, the stronger the complementarity.

[0066] Screening threshold: Particle pairs with a complementarity score ≥ 0.7 are considered to have good complementarity and can enter the candidate set; the artificial intelligence model can use a lightweight graph neural network (GNN) to learn feature relationships and supports online fine-tuning.

[0067] S230: Establishing a command resonance graph and locating the resonant particle swarm: Based on the complementarity candidate pairs from S220, a graph structure is constructed, with particles as nodes and complementarity scores as edge weights. Through resonance graph analysis, the splicable resonant particle swarm is located.

[0068] Definition of resonance:

[0069]

[0070] The above formula is used to measure the "resonance intensity" of a particle swarm as a whole, that is, the average level of complementarity scores among particles within the swarm. Let be the complementarity score between particle i and particle j. E is the edge set containing all particle pairs with complementarity scores. The number of nodes in the particle swarm. The higher the Resonance value, the stronger the complementarity within the particle swarm, making it more suitable as a candidate swarm for splicing. Threshold source: The resonance threshold of 0.6 comes from experimental statistics to ensure that the average resource utilization rate after splicing is ≥70%. Resonance(G) is the "complementarity strength" index of the overall swarm, used to select particle swarms with high complementarity.

[0071] Collision detection formula:

[0072]

[0073] The above formula determines whether two particles conflict in their use of video memory. It is a particle The amount of video memory used; It is a particle The amount of video memory used. This refers to the total video memory capacity of a single GPU. If the combined video memory usage of two particles exceeds 80% of the total video memory, a conflict is considered to exist. If the value is 1), then there is no conflict. (0). This is a local conflict detection formula used to eliminate particle pairs exceeding memory limits. When the result is 1, the edge is eliminated. Sequence feasibility check: The total execution time after concatenation must not exceed the window limit (typically 20ms).

[0074] Data Structure Example (Resonance Graph Side Table)

[0075]

[0076] S240: Candidate group screening based on threshold and system constraints: Based on the resonance graph, the candidate group is further screened by combining system constraints.

[0077] Screening rules: Resonance threshold: Resonance ≥ 0.6; Energy consumption red line: Average power consumption of a single GPU ≤ 200W, total power consumption of a four-GPU cluster ≤ 800W; Latency constraint: Average latency within the cluster ≤ 5ms (from the 95th percentile of actual measurements); Multi-tenant isolation: splicing is only performed within the same tenant domain. Judgment rules:

[0078]

[0079] The above formula represents a multi-tenant isolation condition used to determine whether two particles can be allowed to be combined or spliced. This indicates the tenant number of the task or user to which particle i belongs. This indicates the tenant number of the task or user to which particle j belongs. This indicates an allowed flag. If two particles come from the same tenant ( (same), then A value of 1 indicates that splicing is allowed; if the two particles come from different tenants, then... A value of 0 indicates that splicing is prohibited to avoid interference between tasks of different tenants or data leakage.

[0080] Output: A list of candidate groups is generated for use in the subsequent splicing stage.

[0081] Example of filtering results:

[0082]

[0083] S3. Based on a timing prediction model, predict potential instruction stream gaps during future execution, generate placeholder particles, and insert these placeholder particles into the instruction stream to reduce instruction execution latency; specifically, this includes the following sub-steps:

[0084] S310: Real-time monitoring of instruction pipeline execution status: On the GPU node, a lightweight probe is used to collect real-time data on the instruction pipeline and output an execution status view. Collected metrics: Warp utilization, queue depth, thread bundle readiness, and memory bandwidth usage. Sampling window: Typical range is 5–20ms, derived from GPU vendor performance tuning white papers (such as the NVIDIA Tuning Guide) and experimental statistics.

[0085] Anomaly correction formula: When a sampling point is missing, the neighborhood interpolation method is used (refer to S120): Data structure example:

[0086]

[0087] S320: Prediction of the location and duration of future instruction flow gaps: Based on the state view acquired by S310, a time-series prediction model is used to predict potential future pipeline gaps. Input feature vector:

[0088]

[0089] There are 4–6 dimensions, derived from historical operation logs and real-time monitoring data. Prediction model: LSTM or Transformer architecture can be used, trained via a sliding window. Output: Gap start time. Duration 1. Prediction confidence level C. Threshold: When C ≥ 0.8, it is considered a valid gap prediction.

[0090] The above formula is a feature input vector used in the training or inference phase of an AI model (such as LSTM or Transformer). It combines multiple key performance indicators as input features for the model. It is the instruction queue depth, which represents the length of the current GPU instruction queue and reflects the system's waiting pressure; It is the thread bundle utilization rate, which represents the utilization rate of GPU execution units, with a value range of 0–1; Bandwidth utilization rate represents the proportion of memory or bus bandwidth used, with a value range of 0–1. It is historical latency data, usually stored in time series format, reflecting past waiting and execution situations.

[0091] Example table of predicted output:

[0092]

[0093] Additional notes on AI model parameters: In the implementation of the above time series prediction model, this embodiment specifically uses a two-layer Long Short-Term Memory (LSTM) network with 128 hidden units and a learning rate of 0.001. Input features include key indicators such as warp utilization, instruction queue depth, bandwidth utilization, and historical latency sequences. Training data is derived from GPU scheduling logs over the past 30 days, with a total sample size exceeding 10. 5 The model was trained and validated on this dataset. Experimental results show that the model achieves a prediction accuracy of over 90% for instruction flow gaps, demonstrating its feasibility and applicability in engineering scenarios.

[0094] S330: Placeholder Particle Generation Bound to Resource Budget: Generate placeholder particles within predicted gaps to fill upcoming idle time. Type Determination Criteria: Texture Prefetch Particles: When And bandwidth utilization ≤20%; lightweight computational particles: when And the computing power utilization rate is ≤30%.

[0095] Resource budget constraints (derived from experimental statistics and the NVIDIA Profiling Guide): Memory budget ≤ 64MB; Execution time budget ≤ 1ms; Bandwidth usage ≤ 5%. Consistency guarantee: The execution results of placeholder particles are only written to the isolated area, and references are switched during business calls to ensure zero intrusion.

[0096] Data structure example:

[0097]

[0098] S340: Placeholder Particle Insertion and Sequence Verification: Placeholder particles are inserted into the concatenation sequence of the candidate instruction particle swarm to fill pipeline gaps. Insertion position calculation:

[0099]

[0100] The above formula indicates that the insertion time of the occupant particle is equal to the gap initiation time plus half the gap duration; where It is the predicted start time of the gap; The duration of the gap; This is the final determined insertion point for the placeholder particle. By setting the insertion point in the middle of the gap, the utilization of this time period can be maximized while reducing the risk of conflicts with preceding and following tasks.

[0101] Sequential topology check formula:

[0102]

[0103] The above formula is used to determine whether a placeholder particle is allowed to be inserted into the target instruction stream; Placeholder particles to be inserted; It is the dependency set of the placeholder particle (i.e., the set of instructions that must be completed before it is executed). It is the set of instructions that currently meet the dependency conditions and can be executed directly; Insertion permission flag. Insertion is allowed (value = 1) if the placeholder particle's dependency set is completely contained within the current executable set; otherwise, insertion is not allowed (value = 0). Preemption strategy: If a high-priority task arrives, the placeholder particle immediately yields, and its execution state is written back to the isolation area to avoid task interruption.

[0104] S4. Instruction particles are exchanged between different GPUs through a dynamic splicing network, and the instruction particles are spliced ​​together according to complementarity to form a continuous instruction stream across GPUs; specifically including the following sub-steps:

[0105] S410: Establishes a dynamic stitching network across GPUs: Creates a dynamic communication network for particle stitching between GPU nodes, supporting on-demand channel creation and release. Topology discovery cycle: Typically one scan every 100ms; this value is derived from GPU manufacturer specifications. The statistical range of link latency.

[0106] Capability Descriptor Formula:

[0107] in: Video memory capacity (unit: GB); Bandwidth capacity (unit: GB / s); Number of interconnection channels (e.g.) (Number of Channels). This is a triple used to comprehensively characterize the resource capabilities of a GPU node. When building a cross-GPU dynamic splicing network, this descriptor is used to determine whether a node meets the requirements of a specific task; Security Isolation: In multi-tenant scenarios, each tenant is allocated an independent virtual channel to ensure data security and performance isolation.

[0108] S420: Complementarity Matching and Window Alignment: In a dynamically stitched network, complementary matching is performed on the particle swarm of candidate instructions from different GPU nodes. Time window: typically 20 ms (derived from GPU pipeline clock cycle statistics).

[0109] Matching criteria: Different and complementary types; bandwidth overlap ≤ 30%; latency difference ≤ 5ms. Matching scoring formula:

[0110]

[0111] A comprehensive score is derived by calculating the degree of matching between two particles in terms of bandwidth and time delay; whereby... This indicates the degree of overlap in bandwidth usage (values ​​range from 0 to 1, with smaller values ​​indicating more complementary bandwidth resources). Normalized value representing the difference in latency (values ​​range from 0 to 1, with smaller values ​​indicating closer latency). , It is a weighting factor used to adjust the relative importance of bandwidth and latency (e.g., It is 0.6. (0.4) This means that the less bandwidth overlap, the greater the contribution value; This indicates that the smaller the difference in latency, the greater the contribution value. The higher the value, the stronger the complementarity of the particle pair, making it more suitable as a splicing object. Judgment rule: If... If the value is ≥0.7, the particle pair is added to the splicing list.

[0112] Example table is as follows:

[0113]

[0114] S430: Perform cross-GPU instruction particle splicing: Perform particle-level splicing based on the matching list to form a cross-GPU target instruction stream.

[0115] Zero-copy mechanism: A read-only view is established on the target GPU via a shared memory handle, avoiding redundant data movement; Barrier placement: Lightweight synchronization barriers are inserted before and after the splicing point to ensure correct dependency order; Typical splicing latency: Experimental statistics show latency ≤ 0.5 ms. Splicing execution table:

[0116]

[0117] S440: Target Instruction Stream Distribution and Execution: The concatenated target instruction stream is distributed to the execution units of each GPU for parallel execution. The quality of service metrics in this embodiment can be used... express.

[0118] Service Quality Indicator Constraints: Typical bandwidth limit ≤ 90%, this limit is derived from the safe usage ratio recommended by the GPU manufacturer. Power Consumption Control: If real-time power consumption exceeds 200W, concurrency will be automatically reduced. Temperature Threshold: When the GPU temperature exceeds 85℃ (derived from the GPU's official thermal design parameter TDP), a fallback mechanism will be immediately triggered. Fallback Mechanism: The target instruction stream will fall back to the single-GPU baseline execution mode to ensure that the task is not interrupted. Example of a distributed table:

[0119]

[0120] S5. During the instruction particle splicing process, calculate the performance indicators and energy consumption costs of different splicing schemes, and select the target splicing scheme that maximizes performance and minimizes energy consumption; specifically including the following sub-steps:

[0121] S510: Real-time power consumption and performance metrics acquisition: During the trial run of the target instruction stream, the running status of the GPU node is monitored in real time, and power consumption and performance metrics are collected.

[0122] Data collected: Power consumption (W), temperature (°C), SM (stream processor) utilization (0–1), memory bandwidth utilization (0–1). Sampling period: Typical value is 10ms; Anomaly handling: Anomaly spikes are smoothed using a moving average method, as shown in the following formula:

[0123]

[0124] The above is a moving average smoothing formula used to smooth time series data (such as power consumption, temperature, bandwidth utilization, etc.) to eliminate abnormal spikes or jitter. This represents the smoothed index value at time t. This represents the raw acquired index value at time ti. k is the size of the sliding window, typically ranging from 3 to 5. The structure of the acquired data table is as follows:

[0125]

[0126] S520: Comprehensive Performance-Energy Consumption Assessment: Conducts a comprehensive assessment of the performance and energy consumption of multiple splicing scheme candidates to form a ranking list.

[0127] Performance gain definition:

[0128]

[0129] The above formula measures the percentage improvement in throughput achieved by a given stitching scheme compared to a baseline scheme; where This represents the throughput of the current splicing scheme (the number of tasks completed per unit of time). This represents the throughput of the baseline scheme (typically the unspliced ​​or default scheme). If A value greater than 0 indicates an improvement in performance relative to the baseline; if A value less than 0 indicates that performance has actually decreased.

[0130] Definition of energy consumption cost:

[0131]

[0132] The above formula represents the increase in power consumption of the splicing scheme compared to the baseline scheme; where It is the average power consumption (W) of the splicing scheme. It is the average power consumption (W) of the baseline scheme; if A value greater than 0 indicates that the splicing scheme consumes more power than the baseline; if A value less than or equal to 0 indicates that the splicing scheme is not inferior to the baseline in terms of energy consumption.

[0133] Comprehensive scoring formula:

[0134]

[0135] The above formula combines performance improvement and energy consumption cost to form a comprehensive evaluation index; This represents the performance weighting factor, which determines the importance of performance improvement in the score; It is an energy consumption weighting factor that determines the degree of influence of energy consumption costs in the scoring; it is usually set to a value of... It is 0.6. The value of 0.4 is derived from experimental tuning results. In detail: performance improvements help increase the score; increased power consumption decreases the score; the higher the score, the better the solution. Constraints are based on: power consumption ≤ 200W: from the GPU manufacturer's safe operating limit; latency ≤ 5ms: from the 95th percentile of actual measurements.

[0136] Example of evaluation results:

[0137]

[0138] S530: Scraping Scheme Selection and Arbitration: Based on the evaluation results, the final scraping scheme is selected, and an arbitration strategy is executed. Selection Rule: The scheme with the highest Score that satisfies the constraints is selected as the final scheme. Rollback Strategy: If all candidates fail the constraints, rollback to the most recently stable execution scheme; if still infeasible, rollback to the single-GPU baseline execution mode. Multi-tenant Arbitration: Priority is allocated according to tenant level to ensure the service quality indicator requirements of high-level tenants. Example of arbitration result representation:

[0139]

[0140] S540: Final Solution Execution and Energy Consumption Control: The final solution is applied to the GPU execution unit, and energy consumption and temperature control are implemented during operation. Solution Issuance: The target instruction stream is mapped to the GPU execution queue, and the concurrency and bandwidth limits are set according to the arbitration result. Energy Consumption Control Point Location: Control points should be placed at splicing boundaries and before long-latency instruction segments. If a power consumption surge of ≥10% is detected, a concurrency reduction operation is triggered. Temperature Control Threshold: When the temperature is ≥85℃, rate limiting or concurrency reduction is triggered. Rollback Execution: If temperature control or energy consumption remains abnormal, the execution rolls back to a stable solution to ensure that the task is not interrupted.

[0141] Example of operation monitoring:

[0142]

[0143] S6. Based on real-time feedback data from GPU execution, update the instruction concatenation strategy of the artificial intelligence model to form an evolvable adaptive scheduling mechanism; specifically including the following sub-steps:

[0144] S610: Execution Feedback Data Collection and Scheduling Log Solidification: During task execution, execution feedback data is collected and solidified into a traceable scheduling log. Feedback content includes placeholder particle gains, splicing latency, power consumption curves, and service quality indicators. Cleaning method: Outliers are discarded directly, and missing data is corrected using linear interpolation.

[0145] Log formatting: JSON structure is used, with typical fields as follows:

[0146]

[0147] Retention period: Logs are retained in distributed storage for 30 days (based on GPU cluster operation and maintenance experience) and index retrieval is supported.

[0148] S620: AI Model Update and Policy Snapshot Generation: This feature trains and updates the AI ​​model using scheduling logs and generates policy snapshots. Training data includes particle feature vectors, energy consumption logs, and execution latency distribution. Update cycle: Daily offline training combined with online fine-tuning using real-time data. Loss function formula: Mean squared error (MSE) is used to ensure consistency between predicted and actual service quality metrics.

[0149]

[0150] The above formula is a mean squared error (MSE) loss function, used to measure the difference between the predicted result and the actual result; where This represents the predicted service quality index value for the i-th sample; This represents the true service quality index value of the i-th sample; N is the number of samples. The smaller the difference between the predicted and true values, the better. Approaching 0; when the difference is large, An increase in the value indicates that the model needs further optimization. This is used to guide the training process of the AI ​​model, making the predicted service quality indicator values ​​closer to the actual service quality indicator values. Output: The generated policy snapshot includes threshold settings, placeholder particle ratio, and splicing priority table.

[0151] S630: Snapshot-based optimized stitching scheme generation: Generates an optimized stitching scheme based on the latest policy snapshot. Resource budget formula:

[0152]

[0153] The above formula defines the upper limit of resource usage for a GPU node when executing a task, in order to avoid overload. This indicates the actual video memory usage of the task; This indicates the total video memory capacity of the GPU; This indicates the actual bandwidth used by the task; This represents the total GPU bandwidth capacity. The constraints are: video memory usage cannot exceed 80% of the total capacity; bandwidth usage cannot exceed 70% of the total capacity. These thresholds are typically derived from GPU manufacturer manuals or system maintenance experience to ensure the stability and security of task execution. Generation process: Candidate particle swarms are selected based on the thresholds and priorities in the snapshot, and resource budgets are reallocated.

[0154] Distribute the schedule:

[0155]

[0156] S640: Evolutionary Adaptive Iteration and Rollback Governance: This feature utilizes an evolutionary algorithm to adaptively optimize the scheduling strategy and performs rollback governance when necessary. Triggering Conditions: Iteration begins every hour or when a service quality indicator (SMI) breach occurs. Genetic Algorithm Parameters: Population Size: 50–100; Number of Generations: 20–50; Crossover Rate: 0.7; Mutation Rate: 0.1. Evolutionary Process: Multiple candidate solutions are searched using a genetic algorithm, and the individual with the highest overall score is retained.

[0157] Rollback mechanism path: If the new strategy causes a latency increase of ≥10%, first roll back to the most recent stable strategy; if the service quality indicators are still not met, then roll back to the single GPU baseline execution mode.

[0158] Example of evolutionary iteration results:

[0159]

[0160] 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 and thresholds in the formulas are set by those skilled in the art according to the actual situation.

[0161] 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, as a computer program product. The computer program product includes one or more computer instructions or computer programs. When the computer instructions or computer programs are loaded or executed on a computer, all or part of the processes or functions described in the embodiments of this application are generated. The computer can be a general-purpose computer, a special-purpose computer, a computer network, or other programmable device. The computer instructions can be stored in a computer-readable storage medium or transmitted from one computer-readable storage medium to another. For example, the computer instructions can be transmitted from one website, computer, server, or data center to another website, computer, server, or data center via wired (e.g., infrared, wireless, microwave, etc.) means. The computer-readable storage medium can be any available medium that a computer can access or a data storage device such as a server or data center that includes one or more sets of available media. The available medium can be a magnetic medium (e.g., floppy disk, hard disk, magnetic tape), an optical medium (e.g., DVD), or a semiconductor medium. The semiconductor medium can be a solid-state drive.

[0162] 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 design 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.

[0163] Those skilled in the art will understand that, for the sake of convenience and brevity, the specific working processes of the systems, devices, and modules described above can be referred to the corresponding processes in the foregoing method embodiments, and will not be repeated here.

[0164] In the several embodiments provided in this application, it should be understood that the disclosed systems, apparatuses, and methods can be implemented in other ways. For example, the apparatus embodiments described above are merely illustrative; for instance, the division of modules is only a logical functional division, and in actual implementation, there may be other division methods. For example, multiple modules or components may be combined or integrated into another system, or some features may be ignored or not executed. Furthermore, the coupling or direct coupling or communication connection shown or discussed may be through some interfaces; the indirect coupling or communication connection between apparatuses or modules may be electrical, mechanical, or other forms.

[0165] The modules described as separate components may or may not be physically separate. The components shown as modules may or may not be physical modules; they may be located in one place or distributed across multiple network modules. Some or all of the modules can be selected to achieve the purpose of this embodiment according to actual needs.

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

[0167] If the aforementioned functions are implemented as software functional modules and sold or used as independent products, they can be stored in a computer-readable storage medium. Based on this understanding, the technical solution of this application, in essence, or the part that contributes to the prior art, or a portion of the technical solution, can be embodied in the form of a software product. This computer software product is stored in a storage medium and includes several instructions to cause a computer device (which may be a personal computer, server, or network device, etc.) to execute all or part of the steps of the methods described in the various embodiments of this application. The aforementioned storage medium includes various media capable of storing program code, such as USB flash drives, portable hard drives, read-only memory (ROM), random access memory (RAM), magnetic disks, or optical disks.

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

[0169] 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 resource scheduling method for a cloud rendering cluster based on AI distributed deployment, characterized in that, Includes the following steps: S1. Divide the instruction stream of each GPU execution unit in the distributed GPU cluster into multiple instruction particles, each instruction particle carrying an energy consumption label, a latency label, and a complementarity weight; S2. Use an artificial intelligence model to construct a cross-task instruction resonance graph, perform complementarity detection on instruction particles in different rendering tasks, and identify instruction particle groups that can resonate in the time dimension. S3. Based on the timing prediction model, predict possible gaps in the instruction stream during future execution, generate placeholder particles, and insert the placeholder particles into the instruction stream to reduce instruction execution latency. S4. Instruction particles are exchanged between different GPUs through a dynamic splicing network, and the instruction particles are spliced ​​according to complementarity to form a continuous instruction stream across GPUs; S5. During the assembly of the commanded particles, calculate the performance indicators and energy consumption costs of different assembly schemes, and select the target assembly scheme that maximizes performance and minimizes energy consumption.

2. The cloud rendering cluster resource scheduling method based on AI distributed deployment according to claim 1, characterized in that, It also includes S6, real-time feedback data based on GPU execution, and update the instruction splicing strategy of the artificial intelligence model to form an evolvable adaptive scheduling mechanism.

3. The cloud rendering cluster resource scheduling method based on AI distributed deployment according to claim 1, characterized in that, S1 specifically refers to: Obtain the raw instruction stream of each GPU execution unit in the distributed GPU cluster, the instruction stream including ray tracing instructions, geometry calculation instructions and AI noise reduction instructions; The original instruction stream is divided into multiple fine-grained instruction units according to the execution boundary, and these units are defined as instruction particles. Each instruction particle is assigned an energy consumption tag, a latency tag, and a complementarity weight to characterize the power consumption level, execution time, and complementarity with other instruction particles during execution.

4. The cloud rendering cluster resource scheduling method based on AI distributed deployment according to claim 1, characterized in that, S2 specifically refers to: Based on the instruction particles obtained from S1, a cross-task particle set is constructed, and instruction particles from different rendering tasks are uniformly stored in a shared space. Artificial intelligence models are used to compare the features of the particle set and analyze the energy consumption label, time delay label and complementarity weight of each instruction particle. Based on the comparison results, an instruction resonance diagram is established, and instruction particle groups that can complementarily fill timing gaps are identified in the diagram structure. The instruction particle groups with a resonance degree greater than a preset threshold in the instruction resonance diagram are selected as candidate objects for subsequent splicing.

5. A cloud rendering cluster resource scheduling method based on AI distributed deployment according to claim 1, characterized in that, S3 specifically refers to: Monitor the execution status of the GPU instruction pipeline and obtain upcoming timing gaps in real time; Using a time-series prediction model, the location and duration of possible instruction stream gaps within a preset time period are predicted. At the predicted gap locations, generate occupant particles with low delay and low energy consumption; The placeholder particles are inserted into the splicing sequence of the candidate instruction particle group to fill the gaps in the instruction stream in advance.

6. The cloud rendering cluster resource scheduling method based on AI distributed deployment according to claim 5, characterized in that, The placeholder particles are texture prefetch particles or lightweight computation particles.

7. The cloud rendering cluster resource scheduling method based on AI distributed deployment according to claim 1, characterized in that, S4 specifically refers to: In a distributed cluster environment, a dynamic splicing network is established between GPUs to exchange candidate instruction particles between different GPUs; In the dynamic splicing network, candidate instruction particles from different GPUs are complementaryly matched; based on the matching results, the splicing operation of the instruction particles is performed to form a continuous target instruction stream across GPUs; the target instruction stream is distributed to the corresponding GPU execution units for parallel execution.

8. The cloud rendering cluster resource scheduling method based on AI distributed deployment according to claim 1, characterized in that, S5 specifically refers to: During the formation of the target instruction stream, real-time power consumption data and execution performance metrics of the GPU execution unit are collected; AI models are used to comprehensively evaluate the performance indicators and energy consumption costs of different splicing schemes; In the evaluation results, the splicing scheme with a large performance improvement and a small increase in energy consumption was selected as the final scheme; The final solution is applied to GPU instruction stream execution to achieve a dual optimization of performance and energy consumption.

9. A cloud rendering cluster resource scheduling method based on AI distributed deployment according to claim 2, characterized in that, S6 specifically refers to: The performance feedback data and energy consumption feedback data obtained during GPU execution are stored as scheduling logs; The scheduling logs are used to train an artificial intelligence model to update the resonance features and splicing strategy of the instruction particles; When a new task arrives, an optimized instruction splicing scheme is generated based on the updated model.

10. A cloud rendering cluster resource scheduling method based on AI distributed deployment according to claim 9, characterized in that, The process of S1-S5 is repeated, and the splicing mechanism is continuously updated to form an adaptive and evolving scheduler.

Images