Cloud rendering cluster resource scheduling method based on AI distributed deployment

Abstract

The invention provides a cloud rendering cluster resource scheduling method based on AI distributed deployment, and the method comprises the steps: firstly dividing an original instruction stream into instruction particles carrying an energy consumption label, a time delay label and a complementarity weight, and constructing a cross-task instruction resonance graph to locate a complementary candidate resonance particle swarm; on the basis of time sequence prediction, generating placeholder particles, and performing look-ahead filling on an impending instruction stream gap; carrying out cross-GPU exchange and splicing of particles in the dynamic splicing network, and solidifying the particles into a cross-GPU continuous target instruction stream; meanwhile, real-time power consumption and performance indexes are collected, performance-energy consumption joint evaluation is carried out on multiple candidate splicing schemes, and an optimal scheme is selected and applied. According to the method, on the premise of not changing the business correctness, through assembly line continuity, zero-copy data multiplexing and rollback anchor point guarantee, the occupancy rate of a GPU execution unit is remarkably increased, end-to-end time delay and voltage drop energy consumption are reduced, and the method is suitable for large-scale parallel scenes such as film and television rendering, cloud games and digital twinning.

Description

TECHNICAL FIELD

[0001] The present application relates to the technical field of cloud rendering and distributed GPU resource scheduling, and particularly relates to a cloud rendering cluster resource scheduling method based on AI distributed deployment. BACKGROUND

[0002] With the continuous expansion of the scale of cloud rendering clusters, GPUs have become the core hardware resources supporting graphics rendering, AI inference and large-scale parallel computing. In the prior art, the scheduling of cloud rendering tasks is mainly concentrated at the task level or thread level, and the overall computing power utilization of the cluster is improved through task allocation, load balancing or priority control.

[0003] However, in actual applications, due to the differences in instruction structure and execution timing of different types of rendering tasks (such as ray tracing, geometric calculation and AI noise reduction), the instruction pipeline inside the GPU often has discontinuous execution fragments and hardware execution unit idling, that is, so-called "instruction-level fragmentation". This problem is particularly prominent in multi-task parallel scenarios. Even if the overall computing power resources of the cluster are sufficient, the effective utilization rate of the GPU unit is still hovering at a low level for a long time, resulting in increased rendering delay and energy waste. Therefore, we propose a cloud rendering cluster resource scheduling method based on AI distributed deployment. SUMMARY

[0004] The purpose of the present application is to overcome the shortcomings of the prior art and provide a cloud rendering cluster resource scheduling method based on AI distributed deployment to solve the technical problems mentioned in the background.

[0005] To achieve the above purpose, the present application provides the following technical scheme: A cloud rendering cluster resource scheduling method based on AI distributed deployment, comprising the following steps: S1, dividing the instruction flow of each GPU execution unit in the distributed GPU cluster into a plurality of instruction particles, each instruction particle carrying an energy consumption label, a time delay label and a complementarity weight; S2, using an artificial intelligence model to construct a cross-task instruction resonance graph, detecting the complementarity of instruction particles in different rendering tasks, and identifying instruction particle groups that can form resonance in the time dimension; S3, based on a time sequence prediction model, predicting possible instruction flow gaps in the future execution process, generating placeholder particles, and inserting the placeholder particles into the instruction flow to reduce instruction execution delay; S4, exchanging instruction particles between different GPUs through a dynamic splicing network, splicing the instruction particles according to complementarity, and forming a continuous instruction flow across GPUs; S5, in the instruction particle splicing process, performance indicators and energy consumption costs of different splicing schemes are calculated, and a target splicing scheme maximizing performance and minimizing energy consumption is selected; S6, based on real-time feedback data executed by the GPU, an instruction splicing strategy of the artificial intelligence model is updated to form an evolving adaptive scheduling mechanism.

[0006] Further, S1 is specifically: obtaining original instruction streams of each GPU execution unit in the distributed GPU cluster, the instruction streams including ray tracing instructions, geometric calculation instructions and AI noise reduction instructions; the original instruction streams are divided into a plurality of fine-grained instruction units according to execution boundaries, and defined as instruction particles; an energy consumption label, a time delay label and a complementarity weight are attached to each instruction particle, for representing power consumption level, execution time and complementarity with other instruction particles in the execution process.

[0007] Further, S2 is specifically: based on the instruction particles obtained in S1, a cross-task particle set is constructed, and instruction particles from different rendering tasks are uniformly stored in a shared space; an artificial intelligence model is used to compare features of the particle set, analyze energy consumption labels, time delay labels and complementarity weights of each instruction particle; according to the comparison result, an instruction resonance graph is established, and instruction particle groups capable of complementarily filling time sequence gaps are identified in the graph structure; instruction particle groups with a resonance degree greater than a preset threshold in the instruction resonance graph are screened out as candidate objects for subsequent splicing.

[0008] Further, S3 is specifically: the execution state of the GPU instruction pipeline is monitored, and the upcoming time sequence gap is obtained in real time; a time sequence prediction model is used to predict the possible instruction flow gap position and duration in a future preset period; a placeholder particle with low delay and low energy consumption is generated at the predicted gap position; the placeholder particle is inserted into the splicing sequence of the candidate instruction particle group, for filling the instruction flow gap in advance.

[0009] Further, S4 is specifically: in a distributed cluster environment, a dynamic splicing network between GPUs is established, for exchanging candidate instruction particles between different GPUs; in the dynamic splicing network, candidate instruction particles from different GPUs are complementarily matched; based on the matching result, the splicing operation of the instruction particles is performed to form a continuous target instruction flow across GPUs; the target instruction flow is distributed to the corresponding GPU execution unit for parallel operation.

[0010] Further, S5 is specifically: in the target instruction stream formation process, 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; in the evaluation results, selecting a splicing scheme with large performance improvement amplitude and small energy consumption increase amplitude as the final scheme; applying the final scheme to the GPU instruction stream execution to obtain the double optimization effect of performance and energy consumption.

[0011] Further, S6 is specifically: storing the performance feedback data and energy consumption feedback data obtained in the GPU execution process as a scheduling log; using the scheduling log to train an artificial intelligence model to update the resonance features and splicing strategies of the instruction particles; when a new task arrives, generating an optimized instruction splicing scheme based on the updated model. Repeat the process of S1-S5 to continuously update the splicing mechanism, forming an adaptive evolution scheduler.

[0012] The beneficial effects of the present application are: The present application makes the GPU instruction flow pipeline continuous from discrete by the continuous link of "instruction particleization -> cross-task instruction resonance -> gap prediction and placeholder -> cross-GPU dynamic splicing", avoids hardware execution unit idling, solves the bottleneck of "instruction-level fragmentation leading to low utilization and high latency", eliminates GPU "instruction-level fragmentation" from the root cause, and improves utilization and reduces end-to-end latency.

[0013] Based on timing prediction, "placeholder particles" are generated and actively filled before splicing the existing candidate resonance particle group, so that the GPU changes from "passive waiting for tasks" to "active placeholder", shortens the time and space holes and reduces the queue waiting time, thereby further reducing the execution latency. Anticipatory placeholder and gap filling, compression of short time and space holes, and reduction of queue waiting.

[0014] In the dynamic splicing network, the instruction particles are exchanged and spliced according to complementarity, and are solidified into a continuous instruction stream across GPUs, so that the parallelism and pipeline utilization are improved on the cluster scale, breaking through the limitations of single-card resources and instantaneous bandwidth. Cross-GPU particle-level dynamic splicing forms a continuous instruction stream across devices, breaking through the single-card bottleneck.

[0015] In the splicing process, the performance indicators and energy consumption costs of multiple candidate schemes are evaluated synchronously, the target scheme with "maximum performance and minimum energy consumption" is selected for execution, and the "double optimization of performance and energy consumption" is realized in the application stage. BRIEF DESCRIPTION OF DRAWINGS

[0016] Figure 1 A schematic diagram of a cloud rendering cluster resource scheduling method based on AI distributed deployment according to the present application. DETAILED DESCRIPTION

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

[0018] Example 1: Figure 1 As shown, this embodiment provides a cloud rendering cluster resource scheduling method based on AI distributed deployment, including the following steps: S1. Divide the instruction stream of each GPU execution unit in the distributed GPU cluster into multiple instruction particles, each of which carries an energy consumption label, a delay label, and a complementary weight; S2. Use AI models to build a cross-task command resonance graph, detect the complementarity of command particles in different rendering tasks, and identify groups of command particles that can resonate in the time dimension. S3. Based on the timing prediction model, predict instruction stream gaps that may occur in the future execution process, generate placeholder particles, and insert the placeholder particles into the instruction stream to reduce instruction execution delay; S4. exchanging instruction particles between different GPUs through a dynamic splicing network, splicing the instruction particles according to complementarity, and forming a continuous instruction stream across GPUs; S5. During the instruction particle splicing process, calculating the performance indicators and energy consumption costs of different splicing schemes, and selecting a target splicing scheme with maximum performance and minimum energy consumption; S6: Based on real-time feedback data from GPU execution, update the instruction splicing strategy of the AI ​​model to form an evolvable adaptive scheduling mechanism; S1, dividing the instruction stream of each GPU execution unit in the distributed GPU cluster into multiple instruction particles, each of which carries an energy consumption label, a delay label, and a complementary weight; specifically comprising the following sub-steps: S110: Acquisition of the original instruction stream: In a distributed GPU cluster, the original instruction stream is collected through an instruction stream tracing agent. The collected events include kernel launches, thread launches, memory reads and writes, texture sampling, etc. A unified clock reference is used for time synchronization to ensure the timing consistency of events across nodes. When some events are lost, the gaps are filled through interpolation correction or placeholder completion methods to ensure data continuity and integrity. Collection frequency: Typically, the sampling frequency is 1ms, which can be adjusted to the microsecond level depending on hardware conditions. Implementation tool reference: The tracing agent can call the GPU performance analysis interface commonly used in this field, such as NVIDIA CUPTI.

[0019] Data structure example: S120: Division of instruction particles: In the obtained original instruction stream, the instruction stream is divided into multiple fine-grained instruction units according to execution boundaries (such as kernel start, synchronization points, and resource occupation mutations), which are defined as "instruction particles".

[0020] Granularity range: the minimum granularity is not less than 10 instructions, and the maximum is not more than 1 ms of continuous execution. Dominant type determination criterion: if the proportion of a certain type of instruction in the particle is ≥ 60%, it is determined as the dominant type.

[0021] Particle type and determination rule: light path particle: light interaction instruction proportion ≥ 70%; geometric calculation particle: triangle subdivision / matrix operation instruction proportion ≥ 60%; texture sampling particle: texture loading instruction proportion ≥ 50%; Interpolation correction formula: if missing data occurs, the following formula can be used: wherein is the missing index, are the corresponding index values of adjacent particles, and the average of the two valid values before and after the missing point is used to replace the missing value; it is the most basic and most commonly used interpolation method, which can ensure data continuity and simple calculation.

[0022] Data structure example: S130: Label addition and feature solidification: after the particle division is completed, an energy consumption label, a time delay label, and a complementarity weight are added to each particle, and are solidified and stored in a unified format to ensure that they can be compared and reused in subsequent steps.

[0023] Energy consumption label calculation: The above formula uses the power consumption per unit time to mark the energy consumption level of the particle. represents the power consumption of the GPU when executing the particle; : the duration of the particle from start to end; 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 hierarchical interval: L1: < 50W; L2: 50-150W; L3: > 150W.

[0024] Time delay label calculation: The above formula indicates that the total time delay is equal to the sum of the waiting time and the execution time. Indicates the time a task waits for scheduling or queuing; Indicates the actual execution time of the task on the GPU; this label can fully reflect the latency characteristics of the particle, taking into account both scheduling wait and computation execution; typical classification ranges: L1: <1ms; L2: 1-5 ms; L3: >5 ms; Complementary weight calculation: The above formula calculates the complementarity weight based on the inverse of the memory occupancy rate and the bandwidth occupancy rate, which is used to measure the complementarity of resource utilization. is the video memory occupancy rate (0-1), is the bandwidth occupancy (0–1); 、 is the empirical weight factor, which can be selected according to different hardware characteristics (such as the default value 、 is 0.5); when a particle's video memory usage is low, A larger value makes the particle more "complementary" when matching; when a particle has a lower bandwidth, The value is large, and similarly it can complement high-bandwidth particles. When splicing distributed GPU tasks, It is used to give priority to particle pairs with strong complementarity, thereby balancing resource utilization. Data structure example: In detail: : Measures the energy consumption intensity of particles; : Measure the particle delay characteristics; : Measures the complementarity between particles in video memory / bandwidth.

[0025] S2. Use the AI ​​model to build a cross-task command resonance graph, perform complementarity detection on command particles in different rendering tasks, and identify command particle groups that can resonate in the time dimension. This specifically includes the following sub-steps: S210: Construct a cross-task instruction particle set: In a distributed GPU cluster, instruction particles from different rendering tasks are uniformly stored in a shared space to form a cross-task particle set; Time alignment: Using a unified clock reference, the instruction streams of different tasks are divided into fixed time windows (typical value: 10-50ms), and particles are normalized within the same window; Task identification: Task_ID is attached to each particle to distinguish the source of the task; Consistency check: When the particle labels (energy consumption, latency) of different tasks differ too much, they are not included in the candidate set. The judgment formula is: is the label value of particle i (such as energy consumption label or delay label), is the label value of particle j, the above formula is a consistency check condition for judging whether two label values are close enough. If the relative difference between the two does not exceed 10%, they are considered consistent and can participate in subsequent analysis. S220: Feature comparison and complementarity analysis based on artificial intelligence model: Based on the unified set, the instruction particles are compared by using the artificial intelligence model, the particle pairs with complementarity are identified, and the complementarity score is calculated.

[0026] Input features: energy consumption label, time delay label, memory occupancy rate, bandwidth occupancy rate, execution start and end time, 4-6 dimensions. Training sample source: from historical scheduling logs, covering 10 4 or more particle pairs; Complementarity score formula: Wherein: is the energy consumption difference normalized value; the range is 0-1, the smaller the value, the closer the energy consumption of the two particles; is the time delay difference normalized value; the range is 0-1, the smaller the value, the closer the time delay of the two particles; is the resource occupation overlap degree (0-1); it represents the competition degree of two particles in memory or bandwidth. The larger the value, the more serious the resource overlap; , is a weight factor for adjusting the importance of the three parts in the score; the typical value is 0.4, is 0.3, is 0.3; Energy consumption dimension: , the smaller the energy consumption difference, the greater the contribution. Time delay dimension: , the smaller the time delay difference, the greater the contribution. Resource complementarity dimension: , the less the resource overlap, the greater the contribution. Weighted sum , the closer to 1, the stronger the complementarity.

[0027] Screening threshold: particle pairs with 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) for feature relationship learning and support online fine-tuning.

[0028] ​S230: Construct resonance graph and locate the resonant particle group: According to the complementary candidate pairs in S220, construct a graph structure, with particles as nodes and complementary scores as edge weights. Through resonance graph analysis, locate the resonant particle group that can be spliced.

[0029] Resonance degree definition: The above formula is used to measure the "resonance strength" of a particle group as a whole, that is, the average level of complementary scores between particles in the group, is the complementary score between particle i and particle j. E is the edge set, containing all complementary scores of particle pairs. is the number of nodes in the particle group. The higher the Resonance value, the stronger the complementarity within the particle group, and the more suitable it is to be selected as a splicing candidate group; Threshold source: Resonance threshold 0.6 comes from experimental statistics, ensuring that the average resource utilization after splicing is ≥ 70%; Resonance(G) is the "complementary strength" index of the overall group, which is used to select particle groups with high complementarity.

[0030] Conflict detection formula: The above formula determines whether two particles conflict in the use of video memory. is the video memory occupancy of particle ; is the video memory occupancy of particle . is the total video memory capacity of a single GPU. If the sum of the video memory occupancy of the two particles exceeds 80% of the total video memory, is 1); otherwise, it is determined that there is no conflict ( is 0). is a local conflict detection formula, which is used to eliminate particle pairs with excessive video memory. When the result is 1, the edge is removed. Sequential feasibility check: the total execution time after splicing must not exceed the upper limit of the window (typically 20ms).

[0031] Data structure example (resonance graph edge table) S240: Candidate group screening based on threshold and system constraints: Based on the resonance graph, further screen the candidate groups in combination with system constraints.

[0032] Screening rules: Resonance threshold: Resonance ≥ 0.6; Energy red line: single GPU average power consumption ≤ 200W, four GPU cluster total power consumption ≤ 800W; Time delay constraint: average time delay within the group ≤ 5ms (95th percentile from actual measurement statistics); Multi-tenant isolation: splicing is only performed within the same tenant domain. Judgment rules: The above formula represents a multi-tenant isolation decision condition for determining whether two particles can be allowed to be combined or spliced; represents the tenant number of the task or user to which the particle i belongs. represents the tenant number of the task or user to which the particle j belongs. represents the permission flag. If the two particles come from the same tenant ( same), then is 1, indicating that splicing is allowed; if the two particles come from different tenants, then is 0, indicating that splicing is prohibited to avoid interference between tasks or data leakage between different tenants.

[0033] Output result: form a list of candidate groups for the subsequent splicing stage.

[0034] Filtering result example: S3, based on a timing prediction model, predicts possible instruction stream gaps in future execution, generates placeholder particles, and inserts the placeholder particles into the instruction stream to reduce instruction execution delay; specifically including the following sub-steps: S310: Real-time monitoring of instruction stream pipeline execution state: On the GPU node, real-time collection of the instruction stream pipeline is performed through a lightweight probe, and an execution state view is output. Collection indicators: Warp occupancy, queue depth, thread bundle readiness, memory bandwidth occupancy. Sampling window: The typical interval is 5-20 ms, which is derived from the GPU vendor performance tuning white paper (such as NVIDIA Tuning Guide) and experimental statistics.

[0035] Abnormal correction formula: When a sampling point is missing, a neighborhood interpolation method is used (refer to S120): data structure example: S320: Prediction of the position and duration of future instruction stream gaps: Based on the state view collected in S310, a timing prediction model is used to predict possible future pipeline gaps. Input feature vector: There are 4-6 dimensions, derived from historical running logs and real-time monitoring data. Prediction model: LSTM or Transformer structure can be used, trained through a sliding window. Output result: gap start time , duration , prediction confidence C. Threshold: when C≥0.8, it is considered as a valid gap prediction.

[0036] The above formula is a feature input vector for AI models (such as LSTM, Transformer) in the training or inference stage. It combines multiple key performance indicators together as input features for the model. is the instruction queue depth, representing the length of the current GPU instruction queue, reflecting the waiting pressure of the system; is the thread bundle occupancy, representing the utilization rate of the GPU execution unit, with a value range of 0-1; is the bandwidth usage rate, representing the usage proportion of memory or bus bandwidth, with a value range of 0-1; is the historical latency data, usually stored in the form of time series, reflecting the past waiting and execution situation.

[0037] Example of prediction output table: Supplementary explanation of AI model parameters: In the implementation of the above time series prediction model, this embodiment specifically adopts a two-layer long short-term memory network (LSTM) with 128 hidden units and a learning rate of 0.001. The input features include warp occupancy, instruction queue depth, bandwidth occupancy, and historical latency sequence, etc. The training data comes from the GPU scheduling log of the past 30 days, with a total sample size of more than 10 5 thousands. Training and verification are performed on this dataset, and the experimental results show that the prediction accuracy of the model for instruction flow gaps reaches more than 90%. The experimental results show that the model has feasibility and applicability in engineering scenarios.

[0038] S330: Generation of placeholder particles and binding with resource budget: Generate placeholder particles in the predicted gap to fill the upcoming idle time. Type determination condition: texture prefetch particle: when and bandwidth utilization ≤20%; lightweight computing particle: when and computing power utilization ≤30%.

[0039] Resource budget constraints (derived from experimental statistics and NVIDIA Profiling Guide): video memory budget ≤64MB; execution time budget ≤1ms; bandwidth occupancy ≤5%. Consistency guarantee: the execution result of the placeholder particle is only written to the isolated area, and the reference is switched when the business is called, ensuring zero intrusion.

[0040] Data structure example: S340: Insertion of placeholder particles and sequence verification: insert the placeholder particles into the splicing sequence of the candidate instruction particle group to fill the pipeline gap. Insertion position calculation: The above formula indicates that the insertion time of the placeholder particle is equal to the gap start time plus half of the gap duration; wherein is the predicted gap start time; : the duration of the gap; is the final determined insertion time point of the placeholder particle. By setting the insertion point in the middle of the gap, the time period can be maximized, while reducing the risk of conflict with the previous and subsequent tasks.

[0041] Sequential topology checking formula: The above formula is used to determine whether the placeholder particle is allowed to be inserted into the target instruction stream; : the placeholder particle to be inserted; is the dependency set of the placeholder particle (i.e., the set of instructions that must be completed before execution); is the set of instructions that have already met the dependency conditions and can be executed directly; : insertion permission flag. If the dependency set of the placeholder particle is completely contained in the current executable set, insertion is allowed (value = 1); otherwise, insertion is not allowed (value = 0). Preemption strategy: if a high-priority task arrives, the placeholder particle immediately gives way, and its execution state is written back to the isolation area to avoid task interruption.

[0042] S4, exchange instruction particles between different GPUs through dynamic splicing networks, splice the instruction particles according to complementarity, and form a continuous instruction stream across GPUs; specifically including the following sub-steps: S410: Establish a dynamic splicing network across GPUs: establish a dynamic communication network for particle splicing between cross-GPU nodes, supporting on-demand channel establishment and release. Topology discovery period: typically scanned once every 100ms, which is derived from the statistical range of GPU manufacturers on link delay.

[0043] Capability descriptor formula: wherein: : memory capacity (unit: GB); : bandwidth capability (unit: GB / s); : number of interconnection channels (such as channel number). This is a three-tuple that comprehensively characterizes 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 a multi-tenant scenario, each tenant is allocated an independent virtual channel to ensure data security and performance isolation.

[0044] S420: Complementarity matching and window alignment: In the dynamic stitching network, the candidate instruction particle groups of different GPU nodes are matched for complementarity. Time window: typically 20 ms (derived from GPU pipeline clock cycle statistics).

[0045] Matching condition: different types and complementary; bandwidth overlap ≤ 30%; latency difference ≤ 5 ms. Matching score formula: By calculating the matching degree of the two particles in bandwidth and latency, a comprehensive score is obtained; wherein represents the overlap degree of bandwidth occupation (value 0-1, the smaller the value, the more complementary the bandwidth resource is). represents the normalized value of latency difference (value 0-1, the smaller the value, the closer the latency is); , is a weight factor for adjusting the relative importance of bandwidth and latency (for example is 0.6, is 0.4); the less the bandwidth overlap, the greater the contribution value; the smaller the latency difference, the greater the contribution value. The higher, the stronger the complementarity of the particle pair, the more suitable it is as a stitching object. Judgment rule: if ≥ 0.7, the particle pair enters the stitching list.

[0046] The example table is as follows: S430: Perform cross-GPU instruction particle stitching: perform particle-level stitching according to the matching list to form a target instruction stream across GPUs.

[0047] Zero-copy mechanism: establish a read-only view in the target GPU through a shared memory handle to avoid redundant data transfer; barrier setting position: insert a lightweight synchronization barrier before and after the stitching point to ensure the correct dependency order; typical stitching delay: experimental statistics show that the delay overhead is ≤ 0.5 ms. Stitching execution table: S440: Target instruction stream delivery and execution: deliver the completed target instruction stream to the execution unit of each GPU and run in parallel. The quality of service index in this embodiment can be represented by .

[0048] Quality of Service indicator constraint: typical bandwidth upper limit ≤ 90%, which comes from the safe usage ratio recommended by GPU manufacturers. Energy consumption control: if real-time power consumption exceeds 200W, automatically reduce concurrency. Temperature threshold: when GPU temperature exceeds 85℃ (from the official thermal design parameter TDP of GPU), immediately trigger the fallback mechanism. Fallback mechanism: the target instruction stream falls back to the single-GPU baseline execution mode, ensuring that the task is not interrupted. Table example: S5, in the instruction particle splicing process, the performance indicators and energy consumption costs of different splicing schemes are calculated, and a target splicing scheme with maximum performance and minimum energy consumption is selected; specifically including the following sub-steps: S510: real-time power consumption and performance indicator collection: in the target instruction stream trial running stage, the running state of the GPU node is monitored in real time, and the power consumption and performance indicators are collected; The collected indicators are: power consumption (W), temperature (℃), SM (stream processor) occupancy rate (0-1), and memory bandwidth usage rate (0-1). The sampling period is typically 10ms; abnormal processing: the sliding average method is used to smooth the abnormal peaks, and the formula is as follows: The above is a sliding average smoothing formula, which is used to smooth time series data (such as power consumption, temperature, bandwidth usage, etc.) to eliminate abnormal peaks or jitter, represents the smoothed indicator value at time t. represents the original collected indicator value at time t-i. k is the size of the sliding window, typically 3-5. The collected data table structure is as follows: S520: performance-energy consumption comprehensive evaluation: comprehensive evaluation of performance and energy consumption of multiple splicing scheme candidates, forming a ranking list.

[0049] Performance gain definition: The above formula measures the improvement ratio of a splicing scheme compared to the baseline scheme in throughput; wherein represents the throughput of the current splicing scheme (the number of tasks completed per unit time). represents the throughput of the baseline scheme (usually the unspliced or default scheme). If is greater than 0, it means that the performance is improved relative to the baseline; if is less than 0, it means that the performance is actually decreased.

[0050] Energy cost definition: The above formula represents the increase in power consumption of the splicing solution compared to the baseline solution; is the average power consumption of the splicing solution (W); is the average power consumption of the baseline solution (W); if If it is greater than 0, it means that the splicing solution consumes more power than the baseline; if Less than or equal to 0, indicating that the splicing scheme is not inferior to the baseline in terms of energy consumption.

[0051] Comprehensive scoring formula: The above formula combines performance improvement and energy consumption cost to form a comprehensive evaluation index; Represents the performance weight factor, which determines the importance of performance improvement in the score; It is the energy consumption weight factor, which determines the influence of energy consumption cost in the score; it is usually is 0.6, The value is 0.4, derived from experimental tuning results. Specifically: performance improvements help improve the score; increased energy consumption reduces the score; the higher the score, the better the solution. Constraints are: Power consumption ≤ 200W: derived from the GPU manufacturer's safe operating limit; Latency ≤ 5ms: derived from the 95th percentile of measured statistics.

[0052] Example of evaluation results: S530: Splicing scheme selection and arbitration: Select the final splicing scheme based on the evaluation results and execute the arbitration strategy. Selection rule: Take the scheme with the highest score and that meets the constraints as the final scheme. Fallback strategy: If all candidates fail the constraints, fall back to the most recent stable execution scheme; if it is still not feasible, fall back to the single GPU baseline execution mode. Multi-tenant arbitration: Assign priorities based on tenant levels to ensure the service quality indicator requirements of high-level tenants. Example of arbitration result table: S540: Final plan execution and energy consumption control: Apply the final plan to the GPU execution unit, and implement energy consumption and temperature control during operation. Plan issuance: Map the target instruction stream to the GPU execution queue, and set the concurrency and bandwidth limits based on the arbitration results. Energy consumption control point location: The control point should be placed at the splicing boundary and before the long-delay instruction segment. If a sudden increase in power consumption ≥10% is detected, the concurrency reduction operation is triggered. Temperature control threshold: When the temperature is ≥85°C, the speed limit is triggered or the concurrency is reduced. Fallback execution: If the temperature control or energy consumption continues to be abnormal, fall back to the stable plan to ensure that the task is not interrupted.

[0053] Example of running monitoring table: S6, instructions for updating the artificial intelligence model's instruction splicing strategy based on real-time feedback data executed by the GPU to form an evolving adaptive scheduling mechanism; specifically including the following sub-steps: S610: Collecting feedback data and solidifying scheduling logs: During task execution, collect execution feedback data and solidify it into traceable scheduling logs. Feedback content: including placeholder particle yield, splicing delay, power consumption curve, quality of service indicators. Cleaning method: abnormal values are directly discarded, missing data is corrected by linear interpolation: Log solidification format: JSON structure is used, typical fields are as follows: Retention period: logs are retained in distributed storage for 30 days (derived from GPU cluster operation experience), and index retrieval is supported.

[0054] S620: AI model update and strategy snapshot generation: use the scheduling log to train and update the artificial intelligence model, and generate a strategy snapshot. Training data: particle feature vector, energy consumption log, execution delay distribution. Update cycle: offline training is performed daily, and online fine-tuning is performed in combination with real-time data. Loss function formula: mean square error (MSE) is used to ensure that the predicted service quality indicator value is consistent with the true service quality indicator value: The above formula is a mean square error (MSE) loss function used to measure the difference between predicted and true results; where represents the predicted service quality indicator value of the ith sample; represents the true service quality indicator value of the ith sample; N is the number of samples. When the predicted value and the true value are closer, tends to 0; when the difference is larger, the value increases, indicating that the model needs to be further optimized. Used to guide the training process of the AI model to make the predicted service quality indicator value closer to the true service quality indicator value. Output content: the generated strategy snapshot includes threshold setting, placeholder particle proportion, and splicing priority table.

[0055] S630: Generate an optimized splicing scheme based on the latest strategy snapshot. Resource budget formula: The above formula defines the upper limit of resource usage of the GPU node when executing tasks, to avoid overload. represents the actual occupied video memory capacity of the task; represents the total GPU video memory capacity; represents the actual occupied bandwidth of the task; Represents the total bandwidth capacity of the GPU. The constraint logic is that the memory occupancy cannot exceed 80% of the total capacity, and the bandwidth occupancy cannot exceed 70% of the total capacity. These thresholds are usually obtained from the GPU manufacturer's manual or system operation experience to ensure the stability and safety of task running. The generation process is to filter the candidate particle group according to the thresholds and priorities in the snapshot and reallocate the resource budget.

[0056] Issue the schedule: S640: Evolution of adaptive iteration and rollback management: realize the adaptive optimization of scheduling strategy through evolutionary algorithm, and perform rollback management when necessary. Trigger condition: start iteration every 1 hour or when service quality index violation event occurs. Genetic algorithm parameters: population size: 50-100; iteration number: 20-50; crossover rate: 0.7; mutation rate: 0.1. Evolution process: search multiple candidate schemes based on genetic algorithm, and retain the individual with the highest comprehensive score.

[0057] Rollback mechanism path: if the new strategy leads to an increase in delay ≥10%, first rollback to the last stable strategy; if it still does not meet the service quality index, return to the single GPU baseline execution mode.

[0058] Evolution iteration result example: The above formulas are dimensionless to calculate their numerical values. The formula is obtained by software simulation of a large amount of data to obtain a formula for the current real situation. The preset parameters and threshold values in the formula are set by a person skilled in the art according to the actual situation.

[0059] The above-described embodiments can be implemented in whole or in part by software, hardware, firmware, or any combination thereof. When implemented by software, the above-described embodiments can be implemented in whole or in part in the form of 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, the processes or functions described in the embodiments of the present application are wholly or partially generated. The computer can be a general-purpose computer, a special-purpose computer, a computer network, or other programmable devices. The computer instructions can be stored in a computer-readable storage medium or transmitted from one computer-readable storage medium to another computer-readable storage medium, for example, the computer instructions can be transmitted from one website, computer, server, or data center to another website, computer, server, or data center through a wired (for example, infrared, wireless, microwave, etc.) manner. The computer-readable storage medium can be any available medium that can be accessed by a computer or a data storage device such as a server, data center, etc. containing one or more available medium collections. The available medium can be a magnetic medium (for example, a floppy disk, a hard disk, a magnetic tape), an optical medium (for example, a DVD), or a semiconductor medium. The semiconductor medium can be a solid-state disk.

[0060] Those skilled in the art can appreciate that the modules and algorithm steps of the 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 the functions are implemented in hardware or software depends on the specific application and design constraints of the technical solution. Professionals can use different methods to implement the described functions for each specific application, but such implementation should not be considered beyond the scope of the present application.

[0061] Those skilled in the art can clearly understand that, for the convenience and brevity of the description, the specific working processes of the above-described system, device and module can refer to the corresponding processes in the foregoing method embodiments, which will not be described here.

[0062] In several embodiments provided in the present application, it should be understood that the disclosed system, device and method can be implemented in other ways. For example, the above-described device embodiments are only schematic, for example, the division of the modules is only a logical function division, and actual implementation can have another division manner, for example, multiple modules or components can be combined or integrated into another system, or some features can be ignored or not executed. In addition, the coupling or direct coupling or communication connection between the displayed or discussed each other can be indirect coupling or communication connection through some interfaces, devices or modules, which can be electrical, mechanical or other forms.

[0063] The modules described as separate components may or may not be physically separate, and the components shown as modules may or may not be physical modules, and may be located in one place or distributed on multiple network modules. Part or all of the modules can be selected according to actual needs to achieve the purpose of the embodiment.

[0064] In addition, the functional modules in each embodiment of the present application can be integrated into one processing module, or each module can exist physically alone, or two or more modules can be integrated into one module.

[0065] If the functions are realized in the form of software function modules and sold or used as independent products, they can be stored in a computer readable storage medium. Based on this understanding, the technical solutions of the present application can be embodied in the form of software products, and the computer software products are stored in a storage medium, including a plurality of instructions for making a computer device (which can be a personal computer, a server, or a network device, etc.) execute all or part of the steps of the method described in each embodiment of the present application. The aforementioned storage medium includes: U disk, mobile hard disk, read-only memory (ROM), random access memory (RAM), magnetic disk or optical disk, and various program code storage media.

[0066] The above is only a specific embodiment of the present application, but the protection scope of the present application is not limited thereto. Any person skilled in the art can easily think of changes or replacements within the technical scope disclosed in the present application, which should be included in the protection scope of the present application. Therefore, the protection scope of the present application should be subject to the protection scope of the claims.

[0067] Finally: the above is only the preferred embodiment of the present application, and is not used to limit the present application, any modification, equivalent replacement, improvement, etc. within the spirit and principles of the present application should be included in the protection scope of the present application.

Claims

1. A cloud rendering cluster resource scheduling method based on AI distributed deployment, characterized in that: The steps include: S1. Divide the instruction stream of each GPU execution unit in the distributed GPU cluster into multiple instruction particles, each of which carries an energy consumption label, a delay label, and a complementary weight; S2. Use AI models to build a cross-task command resonance graph, detect the complementarity of command particles in different rendering tasks, and identify groups of command particles that can resonate in the time dimension. S3. Based on the timing prediction model, predict instruction stream gaps that may occur in the future execution process, generate placeholder particles, and insert the placeholder particles into the instruction stream to reduce instruction execution delay; S4. exchanging instruction particles between different GPUs through a dynamic splicing network, splicing the instruction particles according to complementarity, and forming a continuous instruction stream across GPUs; S5. During the instruction particle splicing process, the performance indicators and energy consumption costs of different splicing schemes are calculated, and a target splicing scheme with maximum performance and minimum energy consumption is selected.

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

3. The method for scheduling cloud rendering cluster resources based on AI distributed deployment according to claim 1, characterized in that: S1 is specifically: Obtaining the original 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 denoising instructions; Dividing the original instruction stream into multiple fine-grained instruction units according to execution boundaries and defining them as instruction particles; An energy consumption label, a delay label and a complementarity weight are added to each instruction particle to characterize the power consumption level, execution time and degree of complementarity of the instruction particle with other instruction particles during execution.

4. The method for scheduling cloud rendering cluster resources based on AI distributed deployment according to claim 1, characterized in that: S2 is specifically: Based on the instruction particles obtained in S1, a cross-task particle set is constructed, and instruction particles from different rendering tasks are uniformly stored in a shared space; Using an artificial intelligence model to perform feature comparison on the particle set, and analyzing the energy consumption label, delay label and complementary weight of each instruction particle; Based on the comparison results, an instruction resonance graph is established, and instruction particle groups that can complement each other to fill the timing gaps are identified in the graph structure; The instruction particle group with a resonance degree greater than a preset threshold in the instruction resonance graph is screened out as a candidate for subsequent splicing.

5. The method for scheduling cloud rendering cluster resources based on AI distributed deployment according to claim 1, characterized in that: S3 specifically: Monitor the execution status of the GPU instruction pipeline and obtain upcoming timing gaps in real time; Using a timing prediction model, predict the location and duration of instruction stream gaps that may occur within a preset time period in the future; Generate space-occupying particles with low latency and low energy consumption at the predicted gap locations; The placeholder particles are inserted into the splicing sequence of the candidate instruction particle group to fill the instruction stream gap in advance.

6. The method for scheduling cloud rendering cluster resources based on AI distributed deployment according to claim 5, characterized in that: The placeholder particles are texture pre-fetch particles or lightweight computation particles.

7. The method for scheduling cloud rendering cluster resources based on AI distributed deployment according to claim 1, characterized in that: S4 is specifically: In a distributed cluster environment, a dynamic splicing network between GPUs is established to exchange candidate instruction particles between different GPUs; In the dynamic splicing network, candidate instruction particles from different GPUs are complementary 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 and runs in parallel.

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

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

10. The method for scheduling cloud rendering cluster resources based on AI distributed deployment according to claim 9, characterized in that: Repeat the process of S1-S5, continuously iterate and update the splicing mechanism, and form an adaptive and evolving scheduler.

Images