A method and system for allocating AI computing power on a cloud computing platform considering energy consumption constraints.

Abstract

This invention relates to the field of computing power allocation technology, and provides a method and system for allocating AI computing power on a cloud computing platform that considers energy consumption constraints. The method includes: decomposing AI computing power tasks into sub-units through full semantic parsing; distinguishing strong / weak dependencies and constructing a semantic dependency link graph to achieve precise computing power allocation, thereby saving computing power and improving computational efficiency; extracting strong dependency sub-units to form execution chains; locking the execution order and deploying them to low-energy and stable target nodes to ensure execution stability and reduce energy consumption; identifying surplus intervals in computing power nodes; prioritizing the filling of weak dependency units in the surplus intervals for parallel execution; aggregating unfilled units to low-energy nodes for deployment; and simultaneously executing related weak dependency units during idle periods of the strong dependency chain based on data interaction timing, thereby fully utilizing computing power resources and achieving both computing power savings and improved computational efficiency.

Description

Technical Field

[0001] This invention relates to the field of computing power allocation technology, and more specifically, to a cloud computing platform AI computing power allocation method and system that takes into account energy consumption constraints. Background Technology

[0002] The content in this section only provides background information related to this invention and may not constitute prior art.

[0003] As the core carrier supporting artificial intelligence computing power, cloud computing has become increasingly important as AI computing tasks grow in scale and complexity. Therefore, computing power allocation has become a crucial aspect of cloud platform resource optimization. By rationally scheduling and matching the resources of computing nodes within the cloud platform to meet the processing needs of different computing tasks, computing power allocation is not only fundamental to ensuring the stable operation of the cloud platform but also an important means of balancing resource utilization efficiency and controlling operational energy costs under energy consumption constraints. It has now become a significant research direction in the integration of cloud computing and AI.

[0004] To address the performance optimization problem of cloud servers under energy consumption constraints, existing technologies have proposed relevant solutions. For example, Chinese patent CN111506431A discloses a method for optimizing the performance of cloud servers under energy consumption constraints based on perceived load. This method establishes mathematical models for the performance and power consumption of cloud central servers, transforms the performance optimization problem into a standard knapsack problem, and further constructs a directed acyclic graph. It then combines an improved dynamic programming algorithm to traverse the shortest path to solve for the optimal operating frequency, and finally achieves performance optimization under energy consumption constraints by adjusting the server's operating speed.

[0005] However, this technical solution has significant limitations. Its core focuses on a single-dimensional optimization of cloud server hardware operating parameters, adapting to load changes only by adjusting server operating frequency, without considering the specific characteristics of the computing tasks involved in the computational power allocation. The optimization logic of this method only focuses on balancing the energy consumption and response time of a single server node, failing to achieve collaborative scheduling of multiple computing nodes within the cloud platform. In actual AI computing power task processing, this easily leads to idle and wasted computing resources. Furthermore, it is difficult to reduce the overall energy consumption of the cloud platform through resource collaboration between nodes, ultimately failing to simultaneously achieve the dual goals of energy saving and improved computing efficiency under energy constraints. This deficiency in existing technology makes it insufficiently adaptable to AI computing power allocation scenarios, necessitating the development of a computing power allocation method more suited to AI computing power tasks. Summary of the Invention

[0006] The purpose of this invention is to provide a cloud computing platform AI computing power allocation method and system that considers energy consumption constraints, in order to improve the aforementioned problems. To achieve the above objective, the technical solution adopted by this invention is as follows:

[0007] Firstly, this application provides a cloud computing platform AI computing power allocation method considering energy consumption constraints, including:

[0008] The system receives AI computing power tasks submitted by users, performs full semantic parsing on the AI ​​computing power tasks, and breaks them down into multiple sub-units. Each sub-unit is the smallest execution segment in the AI ​​computing power task that has independent execution semantics and can complete a single computing objective.

[0009] Obtain the relationships between all sub-units, distinguish between strong and weak dependencies based on these relationships, and construct a semantic dependency link graph. A strong dependency is where the output of the preceding sub-unit is the only input of the following sub-unit; a weak dependency is where there is only partial data association between sub-units, and they can be executed in parallel or have their execution order flexibly adjusted.

[0010] Extract all sub-units linked by strong dependencies to form a strong dependency execution chain; lock the execution order of sub-units within the chain; traverse all computing power nodes that are compatible with the semantic type of the strong dependency execution chain; collect the unit time energy consumption and continuous execution stability data of each computing power node executing the strong dependency execution chain; filter out target computing power nodes with energy consumption values ​​lower than the preset threshold and continuous execution without interruption; and deploy the strong dependency execution chain on the target computing power nodes.

[0011] Obtain the computing power occupancy time sequence of the target computing power nodes and identify the computing power surplus interval of each target computing power node; mark all sub-units that are only associated by weak dependencies as weak dependency units, classify the weak dependency units according to semantic type, and prioritize filling the corresponding adaptive node's computing power surplus interval with weak dependency units of the same type for parallel execution; after the unfilled weak dependency units are aggregated according to semantic type, they are deployed to the adaptive computing power node with the lowest energy consumption value for parallel execution.

[0012] When a weakly dependent unit has some data association with a strongly dependent execution chain, the weakly dependent unit is set to be executed during the idle computing time of the corresponding strongly dependent execution chain, based on the timing of their data interaction.

[0013] Furthermore, the step of decomposing into multiple sub-units specifically includes:

[0014] Read the task description file, execution code and computing requirement parameters corresponding to the AI ​​computing power task, and parse the syntax and semantics through the Abstract Syntax Tree (AST) to extract the complete computing logic of the task, the input and output definitions of each computing stage and the execution boundary;

[0015] Based on the core judgment rule of having independent execution semantics and being able to complete a single computational goal, the complete computational logic is segmented at the granularity of the extracted execution boundaries to obtain multiple candidate execution segments;

[0016] Each candidate execution segment is subjected to integrity verification to confirm that it has closed-loop input ports, execution logic and output ports. The candidate execution segments that pass the verification are determined as the final sub-units.

[0017] Furthermore, the step of performing integrity verification on each candidate execution segment also includes:

[0018] For candidate execution segments that fail the verification, secondary granular merging or splitting is performed according to the execution boundary until the independent execution integrity verification is passed.

[0019] Furthermore, after distinguishing between strong and weak dependencies based on the relationship, it also includes:

[0020] Sub-units with strong or weak dependencies are marked and saved to a preset storage area.

[0021] Furthermore, the steps for constructing a semantic dependency link graph specifically include:

[0022] Each sub-unit is used as an independent node in the graph, and the strong and weak dependencies between sub-units are used as the connecting edges of the graph. The connecting edges corresponding to strong dependencies are unidirectional and immutable fixed strong dependency edges, marking the unique correspondence between the output of the preceding unit and the input of the following unit. The connecting edges corresponding to weak dependencies are bidirectional and adjustable weak dependency edges, marking some data association types between units. Based on all nodes, strong dependency edges, and weak dependency edges, a directed semantic dependency link graph is constructed.

[0023] Furthermore, after constructing the directed semantic dependency link graph, it also includes:

[0024] When the execution state of any subunit changes or the dependencies between subunits are adjusted, the state label of the corresponding node and the association attributes of the connecting edges in the graph are updated in real time.

[0025] Furthermore, the steps of collecting energy consumption per unit time and continuous execution stability data for each computing node executing strongly dependent execution chains specifically include:

[0026] Pre-acquire the static computation characteristics of each sub-unit in the strongly dependent execution chain, the inherent hardware parameters of the computing nodes, and the real-time running status parameters;

[0027] Based on static computing characteristics and real-time running status parameters, a pre-set computing power boundary model is used to distinguish between computing-constrained and bandwidth-constrained scenarios, and the execution time of each sub-unit is estimated and accumulated to obtain the total estimated execution time of the execution chain.

[0028] By combining the inherent hardware parameters, the dynamic power consumption of each subunit and the static power consumption of the node are calculated, and the total energy consumption of the execution chain is obtained by summing them up. The energy consumption per unit time is then calculated based on the total estimated duration.

[0029] By combining inherent hardware parameters, real-time operating status parameters, and total estimated duration, and based on a reliability engineering model, and by overlaying load redundancy, environmental fluctuations, and peak load correction, the probability of continuous, uninterrupted execution of the execution chain by the computing node is calculated, which serves as continuous execution stability data.

[0030] Furthermore, it also includes:

[0031] During the execution of any sub-unit, the actual energy consumption, computing power occupancy and task execution progress of each computing node are collected in real time.

[0032] For a strongly dependent execution chain formed by strong dependencies, if the actual energy consumption of the computing power node carrying the execution chain exceeds the preset energy consumption constraint threshold, the execution order of the sub-units in the execution chain remains unchanged, and the sub-units in the chain that have not yet been executed are migrated to a computing power node that can adapt to the semantic type of the strongly dependent execution chain, whose energy consumption per unit time does not exceed the preset energy consumption threshold, has the ability to execute continuously without interruption, and whose energy consumption per unit time is lower than the actual energy consumption of the current carrying node.

[0033] For weakly dependent units, if the actual energy consumption of the computing node carrying the unit exceeds the preset energy consumption constraint threshold, or the node's computing power occupancy rate exceeds the reasonable operating range, the weakly dependent units that have not yet been executed will be migrated to other computing nodes that can adapt to the semantic type of the weakly dependent unit and have a spare range of available computing power.

[0034] Furthermore, based on the timing of data interaction between the two, the steps for weakly dependent units to be executed during the idle computing time of the corresponding strongly dependent execution chain specifically include:

[0035] If a weakly dependent unit needs to provide associated input data to a strongly dependent execution chain, then the execution phase of the corresponding data requirement in the strongly dependent execution chain can only be started after the weakly dependent unit has completed its execution. The weakly dependent unit is preferentially scheduled to be executed during the idle computing power period of the corresponding strongly dependent execution chain node.

[0036] If a weakly dependent unit needs to receive output data from a strongly dependent execution chain, then the execution start point of the weakly dependent unit is set to be after the data output point of the corresponding strongly dependent execution chain.

[0037] Secondly, this application also provides a cloud computing platform AI computing power allocation system that considers energy consumption constraints, including:

[0038] The task parsing module is used to receive AI computing power tasks submitted by users, perform full semantic parsing on the AI ​​computing power tasks, and break them down into multiple sub-units; a sub-unit is the smallest execution fragment in the AI ​​computing power task that has independent execution semantics and can complete a single computing objective.

[0039] The dependency identification module is used to obtain the relationships between all sub-units, distinguish between strong and weak dependencies based on the relationships, and construct a semantic dependency link graph. A strong dependency is when the output of the preceding sub-unit is the only input of the following sub-unit; a weak dependency is when there is only partial data association between sub-units, which can be executed in parallel or have their execution order flexibly adjusted.

[0040] The strong chain deployment module is used to extract all sub-units connected by strong dependencies to form a strong dependency execution chain; lock the execution order of sub-units within the chain; traverse all computing power nodes that are compatible with the semantic type of the strong dependency execution chain; collect the unit time energy consumption and continuous execution stability data of each computing power node in executing the strong dependency execution chain; filter out target computing power nodes with energy consumption values ​​lower than a preset threshold and continuous execution without interruption; and deploy the strong dependency execution chain on the target computing power nodes.

[0041] The weak dependency scheduling module is used to obtain the computing power occupancy time sequence of target computing power nodes and identify the computing power surplus intervals of each target computing power node; it marks all sub-units that are only related by weak dependencies as weak dependency units, classifies weak dependency units according to semantic type, and prioritizes filling weak dependency units of the same type into the computing power surplus intervals of the corresponding adaptive nodes for parallel execution; unfilled weak dependency units are aggregated according to semantic type and deployed to the adaptive computing power node with the lowest energy consumption value for parallel execution.

[0042] The timing coordination module is used to schedule the weakly dependent unit to execute during the idle computing time of the corresponding strongly dependent execution chain when there is some data association between the weakly dependent unit and the strongly dependent execution chain, based on the timing of their data interaction.

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

[0044] This invention receives AI computing tasks and performs full semantic analysis to break them down into the smallest execution segments, or sub-units, that possess independent execution semantics and can complete a single computational goal. It then obtains the relationships between these sub-units, distinguishing between strong and weak dependencies, and constructs a semantic dependency link graph. Based on this graph, it achieves precise computing power allocation, thereby saving computing power and improving computational efficiency. Specifically, it extracts sub-units linked by strong dependencies to form a strong dependency execution chain. After locking the execution order of sub-units within the chain, it traverses suitable computing power nodes and collects data on energy consumption per unit time and continuous execution stability. It then selects target computing power nodes with energy consumption values ​​below a preset threshold and uninterrupted continuous execution to deploy the strong dependency execution chain. This ensures the stable execution of strongly dependent tasks and also selects low-energy-consumption nodes. To further reduce computing power consumption and conserve computing power, the algorithm obtains the computing power occupancy time sequence of the target computing power node to identify the computing power surplus interval. Weak dependency units that are only associated by weak dependencies are classified according to semantic type. Weak dependency units of the same type are prioritized to fill the computing power surplus interval of the corresponding adaptive node for parallel execution. Unfilled weak dependency units are aggregated according to semantic type and deployed to the adaptive computing power node with the lowest energy consumption value for parallel execution. This effectively utilizes idle computing power resources and improves computing efficiency. When there is partial data association between a weak dependency unit and a strong dependency execution chain, the weak dependency unit is set to be executed in the computing power idle period of the corresponding strong dependency execution chain according to the data interaction time sequence of the two. This further optimizes the computing power allocation rhythm, avoids computing power waste, and balances energy saving and computing efficiency improvement. Attached Figure Description

[0045] Figure 1 A flowchart of a cloud computing platform AI computing power allocation method considering energy consumption constraints provided by the present invention;

[0046] Figure 2 This is a flowchart of the full semantic parsing process in this invention;

[0047] Figure 3 This is a schematic diagram of the semantic dependency link graph in this invention;

[0048] Figure 4 This is a schematic diagram illustrating the selection of computing power nodes that strongly depend on the execution chain deployment in this invention;

[0049] Figure 5 This is a timing diagram for filling the computing power surplus interval of weakly dependent units in this invention.

[0050] Figure 6 This is a schematic diagram of an AI computing power allocation system for a cloud computing platform that takes energy consumption constraints into account, provided by the present invention.

[0051] In the diagram: 201, Task parsing module; 202, Dependency identification module; 203, Strong chain deployment module; 204, Weak dependency scheduling module; 205, Time-series coordination module. Detailed Implementation

[0052] To make the objectives, technical solutions, and advantages of the embodiments of the present invention clearer, 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. The components of the embodiments of the present invention described and shown in the accompanying drawings can generally be arranged and designed in various different configurations.

[0053] like Figure 1 As shown in the figure, an AI computing power allocation method for a cloud computing platform considering energy consumption constraints proposed in this embodiment of the invention includes:

[0054] S101 receives AI computing power tasks submitted by users, performs full semantic parsing on the AI ​​computing power tasks, and decomposes them into multiple sub-units; a sub-unit is the smallest execution segment in the AI ​​computing power task that has independent execution semantics and can complete a single computing objective.

[0055] Specifically, the implementation principle of this step is as follows: Most of the AI ​​computing tasks submitted by users are end-to-end coupled complete tasks. Direct overall scheduling has problems such as low computing power matching degree and coarse energy consumption control granularity. By breaking the task coupling through full semantic parsing and decomposing it into sub-units that conform to the definition, the granular decoupling of computing tasks can be realized. From the root, it provides the smallest unit that can be independently controlled for subsequent differentiated computing power scheduling and energy consumption optimization, avoiding the waste of computing power and failure of energy consumption control caused by overall scheduling.

[0056] The step of breaking down the material into multiple sub-units is as follows: Figure 2 As shown, the specific steps include:

[0057] The first step involves reading the task description file, execution code, and computational requirement parameters corresponding to the AI ​​computing task. The principle behind this is to comprehensively acquire the core information of the task. The task description file carries the overall goal and execution requirements of the task, the execution code embodies the specific computational logic, and the computational requirement parameters (such as computing power requirements, data volume, and execution precision) reflect the resource requirements of the task. Combining these three elements allows for a complete reconstruction of the task's execution scenario and computational characteristics. The beneficial effect is to avoid decomposition deviations caused by incomplete information, ensuring that the decomposed sub-units can accurately match the resource capabilities and energy consumption constraints of subsequent computing nodes. Subsequently, the abstract syntax tree (AST) is used to analyze the language... The method analyzes the syntax and semantics to extract the complete computational logic of the task, the input and output definitions of each computational step, and the execution boundaries. The principle of AST parsing is to transform the executable code into a structured abstract syntax tree. By traversing the syntax tree nodes, it identifies the computational statements, logical branches, and data interaction relationships in the code, thereby extracting the core links of the computational logic, input and output parameters, and execution boundaries. Compared with traditional syntax parsing, it can more accurately capture semantic-level relationships, avoid missing hidden computational steps, and clarify the execution boundaries of each step, providing a clear basis for subsequent granular segmentation and reducing semantic destruction during the segmentation process.

[0058] The second step involves using the core judgment rule of having independent execution semantics and being able to complete a single computational goal to segment the complete computational logic at the extracted execution boundaries, resulting in multiple candidate execution segments. The principle is based on the previously extracted execution boundaries, combined with the core judgment criteria of the sub-units, to achieve a reasonable segmentation of the computational logic. This ensures the independence of each candidate segment without disrupting the coherence of the overall computational logic, avoiding overly coarse segmentation that would prevent the sub-units from accurately adapting to computing power nodes and causing inaccurate energy consumption calculations. At the same time, it avoids overly fine segmentation that would increase scheduling overhead and energy consumption, thus achieving a balance between granularity and energy consumption / efficiency.

[0059] The third step involves performing integrity checks on each candidate execution segment to confirm that it has a closed-loop input port, execution logic, and output port. The candidate execution segments that pass the check are determined as the final sub-units. The integrity check aims to determine whether a candidate segment has the necessary conditions for independent execution. A closed-loop input port ensures that the segment can receive valid data, complete execution logic ensures that the segment can achieve a single computational goal, and a closed-loop output port ensures that the computational results of the segment can be called by subsequent stages. This process eliminates candidate segments that do not have independent execution capabilities, avoids execution failures due to incomplete segments, reduces waste of computing resources and energy consumption, and ensures the standardization of the final sub-units, providing a reliable foundation for subsequent dependency analysis and computing power allocation.

[0060] Furthermore, the integrity verification of each candidate execution segment includes: for candidate execution segments that fail the verification, secondary granular merging or splitting is performed according to the execution boundaries until the independent execution integrity verification is passed. The principle of this supplementary step is to address the shortcomings of the initial splitting by optimizing the granularity of the candidate segments through secondary adjustments. For segments with incomplete input-output loops or incomplete execution logic, if the splitting is too fine, they are merged; if the splitting is too coarse, they are further split. This ensures that the final sub-unit meets the independent execution standard, improves the success rate and accuracy of sub-unit decomposition, avoids task decomposition failure due to initial splitting errors, and enhances the flexibility of the method to adapt to the decomposition needs of different types of AI computing power tasks.

[0061] The specific implementation process is as follows: Assume that the AI ​​computing power task submitted by the user is "image recognition task based on deep learning model". The core objective of this task is to preprocess, extract features, detect objects and output results for a batch of input images. First, after receiving the task, the platform reads the task description file (which specifies requirements such as image recognition accuracy, processing batch size, and output format), the execution code (including image preprocessing algorithms, feature extraction models, and object detection logic), and the computational requirements (e.g., 200 GFLOPS computing power, 100 GB data volume, and execution latency ≤ 30 seconds). Then, the platform parses the execution code using an Abstract Syntax Tree (AST) to extract the complete computational logic as "Image Reading → Image Preprocessing (Noise Reduction, Size Normalization) → Feature Extraction (Convolution, Pooling Operations) → Object Detection (Anchor Box Generation, Classification and Regression) → Result Summary Output." The input and output of each step are defined as follows: Image Reading input is the original image file, output is unprocessed image data; Image Preprocessing input is unprocessed image data, output is preprocessed image data; Feature Extraction input is preprocessed image data, output is an image feature vector; Object Detection input is an image feature vector, output is the object detection box coordinates and category; Result Summary Output input is the detection box coordinates and category, output is a recognition result report. The execution boundaries of each step are the start and end positions of function calls in the code. Next, based on the rule of independent execution semantics and single computational objective, five candidate execution segments were obtained by segmenting according to the execution boundary, corresponding to the five computational stages mentioned above. Subsequently, the integrity of the candidate segments was checked. It was found that the "image reading" segment only contained reading logic and did not define the format specification of the output port, so it failed the check. The output format definition module was supplemented by secondary segmentation to make it have a closed loop of input (original image path), execution logic (reading image data) and output (standardized image data and format information). Finally, five sub-units that meet the requirements were determined.

[0062] S102, obtain the association relationships between all sub-units, distinguish between strong and weak dependencies based on the association relationships, and construct a semantic dependency link graph; a strong dependency relationship is that the output of the preceding sub-unit is the only input of the following sub-unit; a weak dependency relationship is that there is only partial data association between sub-units, which can be executed in parallel or the execution order can be flexibly adjusted.

[0063] Specifically, based on the acquired relationships, strong dependencies and weak dependencies are distinguished, and a semantic dependency link graph is constructed. The principle for distinguishing between the two types of dependencies is that different relationships impose different constraints on the execution sequence. Strong dependencies have rigid execution order requirements, while weak dependencies have execution flexibility. Clearly distinguishing between the two allows for differentiated design of scheduling strategies, balancing execution stability and computing power utilization, and avoiding energy consumption caused by using a unified scheduling strategy. For example, if weakly dependent sub-units are executed serially according to strong dependency logic, it will waste the idle resources of computing nodes and increase the overall execution time and energy consumption; if strongly dependent sub-units are executed in parallel, it will lead to task execution failure, resulting in a double waste of computing power and energy consumption. The principle of defining strong dependencies is that under this type of dependency, the execution of subsequent sub-units depends entirely on the output data of preceding sub-units, with no other alternative input sources, and the execution order cannot be changed. Therefore, clearly defining rigid execution boundaries can ensure the correct execution of the core logic of the task, avoid the distortion of calculation results caused by disordered order, and reduce the energy consumption caused by repeated execution. The principle behind weak dependency is that the execution of a sub-unit under this type of dependency does not need to completely depend on the output of a single preceding sub-unit, but only needs to obtain some related data, thus having room for parallel execution. Therefore, adopting the definition in this invention can provide possibilities for subsequent utilization of idle computing power and parallel scheduling.

[0064] The steps for constructing a semantic dependency graph specifically include the following:

[0065] Firstly, each subunit is used as an independent node in the graph.

[0066] Secondly, strong and weak dependencies between sub-units are used as the connecting edges of the graph. The principle is that the connecting edges can intuitively reflect the association type between sub-units, realize the visualization of dependencies, and facilitate the scheduling system to quickly identify the core path and optimization space of the dependency link.

[0067] Third, the connection edges corresponding to strong dependencies are unidirectional and immutable fixed strong dependency edges, marking the unique correspondence between the output of the preceding unit and the input of the following unit. The principle is that the rigid execution order of strong dependencies determines the unidirectionality and immutability of the connection edges. Marking the correspondence between input and output can ensure the accuracy of data interaction, avoid data mismatch, ensure the execution stability of strong dependency links, and reduce redundant calculations and energy waste caused by data interaction errors.

[0068] Fourth, the connecting edges corresponding to weak dependencies are bidirectional and adjustable weak dependency edges, and the data association types between the labeled units are marked. The principle is that the flexibility of weak dependencies determines that the direction and association method of the connecting edges can be adjusted according to the computing power node status. Marking the data association type can clarify the boundary of parallel execution and avoid data conflicts during parallel execution. The beneficial effect is to provide a clear basis for the flexible scheduling of subsequent weak dependency units and the filling of idle computing power, improve computing power utilization, and reduce overall energy consumption.

[0069] Finally, based on all nodes, strong dependency edges, and weak dependency edges, a directed semantic dependency link graph is constructed to facilitate the accurate identification of strong dependency core links and weak dependency optimizable units, providing structured support for the implementation of computing power allocation strategies under energy consumption constraints.

[0070] Furthermore, after constructing the directed semantic dependency link graph, the process also includes: when the execution state of any sub-unit changes, or the dependencies between sub-units are adjusted, updating the state labels of the corresponding nodes and the association attributes of the connecting edges in the graph in real time. The principle behind this supplementary step is that the execution state (e.g., executing, completed, abnormally interrupted) and dependencies of sub-units may change due to factors such as computing node failures, dynamic task adjustments, and data updates. If the graph information is not updated in a timely manner, the scheduling system will make decisions based on outdated information, leading to scheduling errors. Therefore, this supplementary step ensures that the graph information remains consistent with the actual execution situation, improves the dynamic adaptability of scheduling, and promptly avoids computing power idleness and energy consumption losses caused by state changes.

[0071] The specific implementation method of step S102 is as follows: Figure 3As shown, taking the five sub-units (image reading, image preprocessing, feature extraction, object detection, and result summary output) of the "image recognition task based on deep learning model" in S101 as an example, the relationships between each sub-unit are first obtained: the output of image reading is the only input of image preprocessing, the output of image preprocessing is the only input of feature extraction, the output of feature extraction is the only input of object detection, and the output of object detection is the only input of result summary output. The above four sets of relationships are all strong dependencies. If the task also includes two weakly dependent sub-units, "preliminary image quality verification" and "temporary storage of detection results", the "preliminary image quality verification" only needs to obtain part of the data output by the image reading sub-unit (such as image resolution and noise level), without waiting for the image reading to be fully completed, and can be executed in parallel with the image preprocessing sub-unit. The "temporary storage of detection results" only needs to receive part of the data output by the object detection sub-unit (such as detection box coordinates), and can be executed in parallel with the result summary output sub-unit. The relationships between the two and other sub-units are all weak dependencies. Subsequently, the sub-units with the two types of dependencies are labeled, with strong dependency sub-units labeled as "Q1-Q5" and weak dependency sub-units labeled as "R1-R2", and saved to a preset storage area. Next, a semantic dependency link graph is constructed: with Q1-Q5 and R1-R2 as independent nodes, unidirectional fixed strong dependency edges are constructed between Q1 and Q2, Q2 and Q3, Q3 and Q4, and Q4 and Q5, marking their unique input-output correspondence; bidirectional adjustable weak dependency edges are constructed between R1 and Q1, and between R2 and Q4, labeled with "resolution / noise data association" and "detection box coordinate association". If the image preprocessing sub-unit (Q2) experiences execution delay due to fluctuations in the computing power node load, the status label of Q2 in the graph is updated in real time to "execution delay", and its strong dependency edge association attributes with Q1 and Q3 are updated synchronously. The scheduling system can adjust the execution sequence of subsequent sub-units accordingly, avoiding wasted computing power and increased energy consumption caused by other sub-units waiting ineffectively.

[0072] Furthermore, sub-units with strong and weak dependencies are marked and saved to a preset storage area for subsequent execution link verification and adjustment. The principle is that the marked sub-units can quickly identify dependency attributes, and the preset storage area adopts a structured storage method, which facilitates the scheduling system to quickly read and call dependency information, avoids repeated resolution of dependency relationships in subsequent scheduling processes, thereby reducing the computing power overhead of scheduling preprocessing, improving scheduling response speed, and facilitating the verification of execution links in subsequent execution processes, timely detection of dependency mismatch problems, avoiding execution interruption caused by dependency confusion, and reducing energy consumption and task failure risk.

[0073] S103: Extract all sub-units connected by strong dependencies to form a strong dependency execution chain; lock the execution order of sub-units within the chain; traverse all computing power nodes that are compatible with the semantic type of the strong dependency execution chain; collect the unit time energy consumption and continuous execution stability data of each computing power node executing the strong dependency execution chain; filter out target computing power nodes with energy consumption values ​​lower than the preset threshold and continuous execution without interruption; and deploy the strong dependency execution chain on the target computing power nodes.

[0074] Specifically, the principle behind forming a strong dependency execution chain lies in the fact that strong dependencies have rigid execution order constraints. The output of a preceding sub-unit is the unique input of a subsequent sub-unit. By chaining such sub-units together to form an execution chain, the core execution path of the task can be clearly defined, avoiding execution order disorder caused by the dispersed scheduling of factor units. This reduces duplicate executions caused by distorted calculation results, lowers ineffective energy consumption, and provides a clear scheduling unit for subsequent node selection and deployment. Figure 4 As shown. The principle of locking the execution order of sub-units within the chain is that the execution logic of a strongly dependent execution chain has an immutable temporal correlation. Any adjustment to the execution order of any sub-unit will cause the entire chain to fail. Locking the execution order can ensure the accuracy of data interaction between sub-units and avoid the waste of computing power and energy consumption caused by data mismatch.

[0075] Then, all computing power nodes that adapt to the semantic type of the strong dependency execution chain are traversed. The principle is that strong dependency execution chains of different semantic types (such as image processing and data computing) have specific adaptation requirements for the hardware configuration of computing power nodes (such as GPU model, memory bandwidth, and computing architecture). Traversing only the adaptable nodes can avoid the scheduling overhead caused by invalid node matching, while ensuring that the execution chain can make full use of the node hardware advantages, improve execution efficiency, and reduce unit energy consumption.

[0076] Next, data on energy consumption per unit time and continuous execution stability of each computing node are collected to measure the energy consumption level of the node and directly related to the energy consumption constraints of the cloud computing platform. On the other hand, continuous execution stability data determines whether the execution chain will be interrupted due to node failure, load fluctuations, or other factors. Interruptions will lead to waste of previous computing power investment and generate additional energy consumption. Collecting both types of data at the same time can achieve quantitative evaluation of node selection and avoid bias caused by subjective judgment.

[0077] Specifically, the data collection process relies on multi-dimensional parameters and models, and the collection process is as follows:

[0078] First, the static computational characteristics, inherent hardware parameters of computing nodes, and real-time operational status parameters of each sub-unit within the strongly dependent execution chain are obtained in advance. Among these, the static computational characteristic parameters include the single-precision floating-point computational complexity of the sub-units. Total memory accesses Required core count threshold Basic hardware parameters include the rated clock speed of the computing core of the computing node. A single core can perform floating-point operations per clock cycle. Calculate the core dynamic power consumption coefficient Memory dynamic power consumption factor Node static standby power consumption Mean Time Between Failures (MTBF) Heat dissipation efficiency coefficient Real-time operating status parameters include the number of currently available cores on the computing node. Available memory bandwidth Current load redundancy Temperature fluctuation rate Voltage fluctuation rate .

[0079] Secondly, based on static computational characteristics and real-time operational parameters, a pre-defined computational power boundary model (i.e., a roofline computational power model) is used to distinguish between computationally constrained and bandwidth-constrained scenarios. The execution time of each sub-unit is estimated separately and then summed to obtain the total estimated execution chain time. The calculation process is as follows:

[0080] Regarding the first Each subunit is used to calculate its arithmetic strength. Calculate the upper limit of arithmetic strength of computing nodes. for:

[0081] (1)

[0082] like The scenario is determined to be memory bandwidth limited, and the estimated execution time of the sub-unit is [not specified]. .

[0083] like The scenario is determined to be computationally constrained, and the estimated execution time of the sub-unit is [not specified]. .in, The threshold is the smaller of the core count required for a subunit to execute and the current number of available cores on the computing node. In other words, the maximum number of cores a subunit can use during execution cannot exceed its own requirement limit, nor can it exceed the node's current actual available core count.

[0084] Therefore, the total estimated execution time of a strongly dependent execution chain for:

[0085] (2)

[0086] In the formula, The total number of sub-units within a strongly dependent execution chain; For indexing.

[0087] Third, combining the inherent hardware parameters, the dynamic power consumption of each sub-unit and the static power consumption of each node are calculated, and the total energy consumption of the execution chain is obtained by summing them up. The energy consumption per unit time is then calculated based on the total estimated duration. The specific calculations are as follows:

[0088] No. Calculate the dynamic power consumption during the execution of each subunit. for:

[0089] (3)

[0090] No. Dynamic memory power consumption during subunit execution for:

[0091] (4)

[0092] No. Actual dynamic power consumption during subunit execution for:

[0093] (5)

[0094] Total energy consumption of strong dependency execution chains for:

[0095] (6)

[0096] In the formula, The total number of sub-units within a strongly dependent execution chain; For indexing.

[0097] Energy consumption per unit time for:

[0098] (7)

[0099] In the formula, The total number of sub-units within a strongly dependent execution chain; For indexing.

[0100] Fourth, combining the inherent hardware parameters of the computing node, real-time operating status parameters, and the total estimated duration of the strongly dependent execution chain, based on a reliability engineering model and incorporating load redundancy, environmental fluctuations, and peak load corrections, the probability of continuous, uninterrupted execution of the execution chain by the computing node is calculated, serving as continuous execution stability data. The specific calculation formula is as follows:

[0101] Load redundancy correction factor for:

[0102] (8)

[0103] In the formula, This is the pre-calibrated load redundancy impact factor.

[0104] Environmental fluctuation penalty coefficient for:

[0105] (9)

[0106] In the formula, The pre-calibrated temperature influence coefficient; This is the pre-calibrated voltage influence coefficient.

[0107] Equivalent Mean Time Between Failures for:

[0108] (10)

[0109] The sub-unit peak load impact factor (a special operating condition correction coefficient strongly dependent on the execution chain, i.e., the probability of not triggering additional overload failure when the peak load impact of each sub-unit is executed serially) is: ,in, For the first Peak core utilization during the execution of each subunit; Weights are assigned to pre-calibrated peak loads.

[0110] Based on the exponential distribution model in classic reliability engineering (the basic reliability of hardware nodes, i.e., the continuous operation of computing nodes in the current operating environment). The execution chain can only be uninterrupted if both the load impact factor and the exponential distribution model risks do not occur simultaneously, thus yielding the probability of continuous, uninterrupted execution. for:

[0111] (11)

[0112] In the formula, This is the exponential distribution model used in classic reliability engineering.

[0113] Next, target computing nodes with energy consumption values ​​below a preset threshold and continuous, uninterrupted execution are selected. The principle is that the preset energy consumption threshold is a core indicator set based on the overall energy consumption constraints of the cloud computing platform. Being below this threshold ensures that the energy consumption of nodes executing strongly dependent execution chains meets the control requirements, while continuous, uninterrupted execution ensures that the execution chain does not need to be restarted repeatedly, avoiding additional energy consumption. The combination of the two achieves a balance between energy consumption and stability in the selection process. The beneficial effect is that it accurately identifies high-stability nodes that meet energy consumption constraints, implements energy consumption control objectives at the execution carrier level, and reduces the risk of task interruption.

[0114] Finally, the strongly dependent execution chain is deployed on the target computing power node. The principle is to centrally deploy the strongly dependent execution chain to the selected target node, which can reuse the computing power resources of the node that has been activated, avoid the additional static energy consumption caused by adding idle nodes. At the same time, centralized deployment can reduce the energy consumption of cross-node data transmission between sub-units and improve execution efficiency. The beneficial effect is to achieve the overall effect of S103: to save computing power by reusing the idle computing power of activated nodes, to shorten the overall task cycle by parallel execution to improve computing efficiency, and to avoid the additional energy consumption of adding idle nodes by prioritizing the reuse of nodes, thus meeting the energy consumption constraint.

[0115] The specific implementation is as follows: Taking the "image recognition task based on deep learning model" in S101 and S102 as an example, its strongly dependent execution chain is Q1 (image reading) - Q2 (image preprocessing) - Q3 (feature extraction) - Q4 (object detection) - Q5 (result summary output). First, the serial link is extracted and the execution order of Q1 to Q5 is locked to avoid timing disorder. Then, the GPU computing power nodes adapted to image processing semantics in the cloud computing platform (a total of 3, namely node 1, node 2, and node 3) are traversed. Data of each node is collected: the static computing characteristics of Q1-Q5 (such as total computing power requirement of 200GFLOPS, data volume of 100GB), the inherent parameters of node hardware (such as rated power consumption of 80W for node 1, rated power consumption of 75W for node 2, and rated power consumption of 90W for node 3) and the real-time running status parameters (such as the current load rate of node 1 of 30%, the load rate of node 2 of 25%, and the current load rate of node 3) are obtained in advance. (Point 3 load rate 40%). Using a computing power boundary model, scenarios were differentiated, identifying Q1 (image reading) as a bandwidth-constrained scenario and Q2-Q5 as computationally-constrained scenarios. The execution time of each sub-unit was estimated and summed to obtain a total estimated time of 30 seconds. The total energy consumption of each node was calculated: Node 1 had a total energy consumption of 2.1Wh and an energy consumption per unit time of 0.07W / s; Node 2 had a total energy consumption of 1.95Wh and an energy consumption per unit time of 0.065W / s; Node 3 had a total energy consumption of 2.52Wh and an energy consumption per unit time of 0.084W / s. Through a reliability engineering model, the outage probability of Node 1 and Node 2 was 0, while the outage probability of Node 3 was 0.6%. Node 1 and Node 2 were selected as target computing power nodes. Q1-Q3 were deployed on Node 1, and Q4-Q5 were deployed on Node 2, reusing the idle computing power of the two nodes to avoid the idle energy consumption of the newly added nodes. This also ensured the stable and efficient execution of the strongly dependent execution chain, meeting energy consumption constraints.

[0116] S104, such as Figure 5As shown, the computing power occupancy time sequence of the target computing power nodes is obtained, and the computing power surplus interval of each target computing power node is identified; all sub-units that are only associated by weak dependencies are marked as weak dependency units, and weak dependency units are classified according to semantic type. Weak dependency units of the same type are preferentially filled into the computing power surplus interval of the corresponding adaptive node for parallel execution; unfilled weak dependency units are aggregated according to semantic type and deployed to the adaptive computing power node with the lowest energy consumption value for parallel execution.

[0117] Specifically, the principle of identifying the computing power surplus interval of each target computing power node is that the target computing power node has been screened by S103 and deployed with a strong dependency execution chain. The execution process of each sub-unit of the strong dependency execution chain has dynamic computing power occupancy fluctuations and is not always in a full-load operation state. By collecting the computing power occupancy time series data of the target computing power node in real time, it is possible to accurately capture the idle computing power period generated by the node during the execution gap of the strong dependency execution chain, that is, the computing power surplus interval.

[0118] Secondly, all sub-units associated only by weak dependencies are marked as weak dependency units. The principle behind this is that weak dependency units have only partial data associations with strong dependency execution chains and other weak dependency units, without rigid execution order constraints. They possess the characteristics of independent scheduling, flexible deployment, and parallel execution. By separately marking weak dependency units, their distinction from strong dependency execution chains can be clearly achieved, avoiding dependency confusion during scheduling. This facilitates the development of differentiated scheduling strategies for weak dependency units, improving scheduling accuracy and efficiency. Weak dependency units are also classified by semantic type. The principle behind this is that different semantic types of weak dependency units (such as image data verification, detection result storage, and data format conversion) have specific adaptation requirements for the hardware configuration and computing architecture of computing nodes. For example, image-related weak dependency units are more suitable for GPU nodes with high memory bandwidth, while data storage weak dependency units are more suitable for nodes with high IO efficiency. Classifying by semantic type allows for precise adaptation between weak dependency units and computing nodes, thereby improving the execution efficiency of weak dependency units.

[0119] Then, weakly dependent units of the same type are prioritized to be filled into the surplus computing power range of the corresponding adaptive node for parallel execution. The principle is that the target computing power node is already in an active state, and the idle computing power in its surplus computing power range will result in ineffective energy consumption if not utilized. However, by filling the surplus computing power range of the adaptive node with weakly dependent units of the same type, the computing power resources of the node that have already been activated can be fully reused without the need to start new computing power nodes. At the same time, there are no strong dependency constraints between weakly dependent units, and parallel execution can significantly shorten the overall execution time of weakly dependent units, thereby shortening the cycle of the entire AI computing power task. This achieves efficient reuse of computing power resources, avoids the waste of idle computing power, improves task execution efficiency through parallel execution, and reduces the idle energy consumption of new computing power nodes by eliminating the need for new computing power nodes.

[0120] Finally, the unfilled weakly dependent units are aggregated by semantic type and deployed in parallel on the suitable computing power node with the lowest energy consumption. The principle is that some weakly dependent units may not be filled due to limited capacity in the target computing power node's spare capacity or semantic mismatch. Aggregating these unfilled units by semantic type enables centralized scheduling of units of the same type, reducing scheduling complexity. Simultaneously, selecting the suitable computing power node with the lowest energy consumption ensures that the execution energy consumption of the unfilled weakly dependent units remains within a controllable range, meeting the overall energy consumption constraint target, and allowing for parallel execution. The execution avoids the surge in energy consumption caused by excessive load on a single node, and achieves efficient deployment of all weakly dependent units. This ensures the integrity of AI computing tasks and further reduces overall energy consumption by selecting low-energy-consumption adaptive nodes. Meanwhile, parallel execution avoids task delays caused by scheduling of a single node, balancing energy consumption constraints and execution efficiency. Finally, it saves computing power by reusing the idle computing power of activated nodes, shortens the overall task cycle by parallel execution to improve computing efficiency, and avoids the additional energy consumption of adding idle nodes by prioritizing node reuse, thus meeting energy consumption constraints.

[0121] The specific implementation process of this step is as follows: Taking the "image recognition task based on deep learning model" in the above embodiment as an example, in S103, node 1 and node 2 have been selected as target computing power nodes. Node 1 deploys a strongly dependent execution chain Q1 (image reading) - Q2 (image preprocessing) - Q3 (feature extraction), and node 2 deploys a strongly dependent execution chain Q4 (object detection) - Q5 (result summary output). First, the computing power usage time series data of node 1 and node 2 are obtained. Through real-time monitoring, it is found that node 1 has a 5-second computing power surplus interval after Q1 is completed (takes 8 seconds) and before Q2 starts. During the execution of Q2 (takes 10 seconds), due to the fluctuation of computing power demand in Q2, there is a 3-second computing power surplus interval. Node 2 has a 4-second computing power surplus interval after Q4 is completed (takes 7 seconds) and before Q5 starts. In the early stage of Q5 execution, there is a 2-second computing power surplus interval. Subsequently, sub-units R1 (preliminary image quality verification), R2 (temporary storage of detection results), and newly added weakly dependent units R3 (image data backup) and R4 (detection result format conversion), which are only associated by weak dependencies, are marked as weakly dependent units. After being classified by semantic type, R1 and R3 belong to the image data processing category (adapting to GPU nodes), while R2 and R4 belong to the detection result processing category (adapting to GPU nodes with high IO efficiency). Weakly dependent units of the same type are preferentially filled into the computing power surplus interval of the corresponding adapted nodes: R1 is filled into the 5-second surplus interval between Q1 and Q2 of node 1, and R3 is filled into the 3-second surplus interval during the execution of Q2 of node 1, and the two are executed in parallel; R2 is filled into the 4-second surplus interval between Q4 and Q5 of node 2, realizing the reuse of computing power with the strong dependency execution chain of node 2. Unfilled weak dependency units R4 (detection result format conversion) are aggregated by semantic type. Then, the computing power nodes in the cloud computing platform that adapt to the detection result processing class are traversed, and the node with the lowest energy consumption (node ​​4, energy consumption of 0.05W / s per unit time, lower than other adaptable nodes) is selected and deployed on node 4 for parallel execution. This implementation fully utilizes the idle computing power of nodes 1 and 2, without adding any additional idle nodes, reducing static energy consumption. Simultaneously, all weak dependency units are executed in parallel, significantly shortening the execution time of weak dependency units, thus saving computing resources and improving overall task execution efficiency.

[0122] S105, when there is partial data association between a weakly dependent unit and a strongly dependent execution chain, the weakly dependent unit is set to be executed during the idle computing time of the corresponding strongly dependent execution chain according to the timing of their data interaction.

[0123] Specifically, S105 aims to address the scheduling optimization problem when weakly dependent units and strongly dependent execution chains have partial data associations. Its principle is to achieve reasonable scheduling of weakly dependent units by precisely matching the data interaction timing between the two with the idle computing power periods of the strongly dependent execution chain, thereby dynamically maintaining a balance between energy consumption constraints, computing power conservation, and improved computational efficiency. For the two specific data interaction scenarios, separate scheduling strategies need to be developed:

[0124] The first approach involves weakly dependent units providing associated input data to the strongly dependent execution chain. The output of such weakly dependent units is a necessary input (not a unique input, distinct from a strong dependency) to the corresponding stage of the strongly dependent execution chain. If a weakly dependent unit fails to complete its execution, the corresponding strongly dependent stage cannot start. In this case, the weakly dependent unit is constrained to start only after completion, and it is prioritized for scheduling during idle periods of the strongly dependent execution chain's host node. This allows for the reuse of the node's already activated computing resources, avoiding idle energy consumption of new nodes. It also prevents weakly dependent units and strongly dependent execution chains from competing for the same node's computing power, reducing energy consumption, and ensures that the strongly dependent execution chain can obtain the necessary data in a timely manner, preventing execution interruptions.

[0125] The second type is where weakly dependent units need to receive output data from strongly dependent execution chains. The execution of such weakly dependent units depends on the output of the corresponding strongly dependent link. If they start prematurely, execution will fail due to missing data, resulting in wasted computing power and energy. Therefore, the start time of their execution is set after the output time of the corresponding strongly dependent data, thereby ensuring that the weakly dependent units execute successfully at once and avoiding the energy consumption of repeated execution.

[0126] The specific example is as follows: Following the "image recognition task based on deep learning model" in the previous embodiment, the strong dependency execution chain is Q1-Q5, the weak dependency unit R1 (preliminary image quality verification) needs to provide associated input data (image noise level verification result) to Q2 (image preprocessing), and R2 (temporary storage of detection results) needs to receive the output data (detection box coordinates) of Q4 (object detection). For R1, since it needs to provide input to Q2, Q2 can only be started after R1 has finished executing. At the same time, it is prioritized to be scheduled to the idle computing power period of the node carrying Q1 (node ​​1) (the 5-second spare interval after Q1 finishes executing), reusing the idle computing power of node 1. No new node needs to be added, avoiding idle energy consumption. At the same time, it ensures that Q2 can obtain the verification data in time to avoid execution abnormalities. For R2, since it needs to receive the output data of Q4, its execution start point is set to be after Q4 finishes executing (taking 7 seconds), which exactly matches the 4-second spare interval of node 2, realizing computing power reuse. This avoids the execution failure caused by R2 starting early, and makes full use of idle computing power, ultimately achieving a dynamic balance between energy consumption constraints, computing power saving and computing efficiency.

[0127] Furthermore, the above method also includes:

[0128] During the execution of any subunit, the actual energy consumption, computing power occupancy, and task execution progress of each computing node are collected in real time. The principle is that during the execution of the subunit, the energy consumption and computing power occupancy of the computing nodes will fluctuate dynamically with the task load, and the task execution progress may also deviate due to node failures and load fluctuations. Real-time collection of the above data can accurately grasp the node operating status and task progress, and avoid energy consumption out of control or scheduling decision errors due to the lag in status information.

[0129] For strongly dependent execution chains formed by strong dependencies, if the actual energy consumption of the computing nodes carrying the execution chain exceeds a preset energy consumption constraint threshold, the execution order of the sub-units within the chain remains unchanged. The principle is that strongly dependent execution chains have rigid timing constraints; changes in order can lead to task execution failures, distorted calculation results, and additional energy consumption from repeated executions. Maintaining the order ensures the stability of the core task logic. Unexecuted sub-units within the chain are migrated to computing nodes that can adapt to the semantic type of the strongly dependent execution chain, whose energy consumption per unit time does not exceed the preset energy consumption threshold, have continuous and uninterrupted execution capabilities, and whose energy consumption per unit time is lower than the actual energy consumption of the current carrying node. The principle is that adapting to the semantic type ensures efficient execution of sub-units, low-energy-consumption and high-stability nodes balance energy consumption constraints and execution reliability, and migrating unexecuted sub-units prevents the current high-energy-consumption node from continuously consuming energy. This achieves rapid energy consumption control within constraints without affecting the stability of the strongly dependent execution chain, reducing overall energy loss.

[0130] For weakly dependent units, if the actual energy consumption of the computing node supporting the unit exceeds the preset energy consumption constraint threshold, or the node's computing power utilization rate exceeds the reasonable operating range, the unexecuted weakly dependent units will be migrated to other computing nodes that can adapt to the semantic type of the weakly dependent unit and have a surplus of available computing power. The principle is that weakly dependent units have no rigid timing constraints and possess flexible migration characteristics. Migrating them to suitable nodes with surplus computing power allows for the reuse of idle computing power and avoids the risk of current node overload. This achieves both controlling energy consumption within limits and improving computing power utilization, avoiding execution delays caused by node overload, while also eliminating the need to add idle nodes and reducing static energy consumption.

[0131] The specific implementation is as follows: Continuing with the aforementioned image recognition task, Q1-Q3 in the strongly dependent execution chain Q1-Q5 are deployed on node 1. If the actual energy consumption of node 1 exceeds the preset threshold during execution, the execution order of Q1-Q5 remains unchanged, and the unexecuted Q3 is migrated to node 4, which is adapted to image processing, has lower energy consumption per unit time, and has no interruption capability. The weakly dependent unit R4 is deployed on node 4. If the computing power utilization rate of node 4 exceeds the reasonable range, the unexecuted R4 is migrated to node 2, which is adapted to detection result processing and has a surplus computing power range. This ensures the normal progress of the task while keeping energy consumption within the constraints.

[0132] like Figure 6 As shown, based on the same inventive concept, this embodiment provides a cloud computing platform AI computing power allocation system that considers energy consumption constraints, including:

[0133] The task parsing module 201 is used to receive AI computing power tasks submitted by users, perform full semantic parsing on the AI ​​computing power tasks, and break them down into multiple sub-units; the sub-unit is the smallest execution segment in the AI ​​computing power task that has independent execution semantics and can complete a single computing objective.

[0134] The dependency identification module 202 is used to obtain the association relationship between all sub-units, distinguish strong dependency relationship and weak dependency relationship based on the association relationship, and construct a semantic dependency link graph; strong dependency relationship is that the output of the preceding sub-unit is the only input of the following sub-unit; weak dependency relationship is that there is only partial data association between sub-units, which can be executed in parallel or the execution order can be flexibly adjusted.

[0135] The strong chain deployment module 203 is used to extract all sub-units connected by strong dependencies to form a strong dependency execution chain, lock the execution order of sub-units within the chain, traverse all computing power nodes that are compatible with the semantic type of the strong dependency execution chain, collect the unit time energy consumption and continuous execution stability data of each computing power node executing the strong dependency execution chain, filter out target computing power nodes with energy consumption values ​​lower than a preset threshold and continuous execution without interruption, and deploy the strong dependency execution chain on the target computing power nodes.

[0136] The weak dependency scheduling module 204 is used to obtain the computing power occupancy time sequence of the target computing power nodes and identify the computing power surplus interval of each target computing power node; all sub-units that are only associated by weak dependency relationships are marked as weak dependency units, weak dependency units are classified according to semantic type, and weak dependency units of the same type are preferentially filled into the computing power surplus interval of the corresponding adaptive node for parallel execution. Unfilled weak dependency units are aggregated according to semantic type and deployed to the adaptive computing power node with the lowest energy consumption value for parallel execution.

[0137] The timing coordination module 205 is used to set the weakly dependent unit to be executed during the idle computing time of the corresponding strongly dependent execution chain when there is partial data association between the weakly dependent unit and the strongly dependent execution chain, according to the timing of the data interaction between the two.

[0138] It should be noted that the specific methods by which each module performs operations in the system described in the above embodiments have been described in detail in the embodiments related to the method, and will not be elaborated here.

[0139] The above are merely preferred embodiments of the present invention and are not intended to limit the present invention. Various modifications and variations can be made to the present invention by those skilled in the art. Any modifications, equivalent substitutions, improvements, etc., made within the spirit and principles of the present invention should be included within the scope of protection of the present invention.

Claims

1. A method for allocating AI computing power on a cloud computing platform considering energy consumption constraints, characterized in that, include: The system receives AI computing power tasks submitted by users, performs full semantic parsing on the AI ​​computing power tasks, and decomposes them into multiple sub-units; each sub-unit is the smallest execution segment in the AI ​​computing power task that has independent execution semantics and can complete a single computing objective. Obtain the relationships between all the sub-units, distinguish between strong and weak dependencies based on the relationships, and construct a semantic dependency link graph; The strong dependency relationship is that the output of the preceding sub-unit is the only input of the subsequent sub-unit; the weak dependency relationship is that there is only partial data association between sub-units, which can be executed in parallel or have their execution order flexibly adjusted. Extract all sub-units linked by strong dependencies to form a strong dependency execution chain; lock the execution order of sub-units within the chain; traverse all computing power nodes that are compatible with the semantic type of the strong dependency execution chain; collect the unit time energy consumption and continuous execution stability data of each computing power node executing the strong dependency execution chain; filter out target computing power nodes with energy consumption values ​​lower than a preset threshold and continuous execution without interruption; and deploy the strong dependency execution chain on the target computing power nodes. Obtain the computing power occupancy time sequence of the target computing power nodes and identify the computing power surplus range of each target computing power node; All sub-units that are only associated by weak dependencies are marked as weak dependency units. Weak dependency units are classified according to semantic type. Weak dependency units of the same type are prioritized to be filled into the computing power surplus range of the corresponding adaptation node for parallel execution. Unfilled weak dependency units are aggregated according to semantic type and deployed to the adaptation computing power node with the lowest energy consumption value for parallel execution. When a weakly dependent unit has some data association with a strongly dependent execution chain, the weakly dependent unit is set to execute during the idle computing time of the corresponding strongly dependent execution chain, based on the timing of their data interaction.

2. The AI ​​computing power allocation method for a cloud computing platform considering energy consumption constraints according to claim 1, characterized in that, The step of disassembling to obtain multiple sub-units specifically includes: Read the task description file, execution code and computing requirement parameters corresponding to the AI ​​computing power task, and parse the syntax and semantics through the Abstract Syntax Tree (AST) to extract the complete computing logic of the task, the input and output definitions of each computing link and the execution boundary; Based on the core judgment rule of having independent execution semantics and being able to complete a single computational goal, the complete computational logic is segmented at the granularity of the extracted execution boundaries to obtain multiple candidate execution segments; Each candidate execution segment is subjected to integrity verification to confirm that it has closed-loop input ports, execution logic and output ports. The candidate execution segments that pass the verification are determined as the final sub-units.

3. The AI ​​computing power allocation method for a cloud computing platform considering energy consumption constraints according to claim 2, characterized in that, The step of performing integrity verification on each candidate execution segment further includes: For candidate execution segments that fail the verification, secondary granular merging or splitting is performed according to the execution boundary until the independent execution integrity verification is passed.

4. The AI ​​computing power allocation method for a cloud computing platform considering energy consumption constraints according to claim 1, characterized in that, After distinguishing between strong and weak dependencies based on the aforementioned association, the process further includes: Sub-units with strong or weak dependencies are marked and saved to a preset storage area.

5. The AI ​​computing power allocation method for a cloud computing platform considering energy consumption constraints according to claim 1, characterized in that, The steps for constructing the semantic dependency link graph specifically include: Each sub-unit is used as an independent node in the graph, and the strong and weak dependencies between sub-units are used as the connecting edges of the graph. The connecting edges corresponding to strong dependencies are unidirectional and immutable fixed strong dependency edges, marking the unique correspondence between the output of the preceding unit and the input of the following unit. The connecting edges corresponding to weak dependencies are bidirectional and adjustable weak dependency edges, marking some data association types between units. Based on all nodes, strong dependency edges, and weak dependency edges, a directed semantic dependency link graph is constructed.

6. The AI ​​computing power allocation method for a cloud computing platform considering energy consumption constraints according to claim 5, characterized in that, After constructing the directed semantic dependency link graph, the following is also included: When the execution state of any subunit changes or the dependencies between subunits are adjusted, the state label of the corresponding node and the association attributes of the connecting edges in the graph are updated in real time.

7. The AI ​​computing power allocation method for a cloud computing platform considering energy consumption constraints according to claim 1, characterized in that, The steps of collecting unit-time energy consumption and continuous execution stability data for each computing node executing the strongly dependent execution chain specifically include: Pre-acquire the static computation characteristics of each sub-unit in the strongly dependent execution chain, the inherent hardware parameters of the computing nodes, and the real-time running status parameters; Based on static computing characteristics and real-time running status parameters, a pre-set computing power boundary model is used to distinguish between computing-constrained and bandwidth-constrained scenarios, and the execution time of each sub-unit is estimated and accumulated to obtain the total estimated execution time of the execution chain. By combining the inherent hardware parameters, the dynamic power consumption of each subunit and the static power consumption of the node are calculated, and the total energy consumption of the execution chain is obtained by summing them up. The energy consumption per unit time is then calculated based on the total estimated duration. By combining inherent hardware parameters, real-time operating status parameters, and total estimated duration, and based on a reliability engineering model, and by overlaying load redundancy, environmental fluctuations, and peak load correction, the probability of continuous, uninterrupted execution of the execution chain by the computing node is calculated, which serves as continuous execution stability data.

8. The AI ​​computing power allocation method for a cloud computing platform considering energy consumption constraints according to claim 1, characterized in that, Also includes: During the execution of any sub-unit, the actual energy consumption, computing power occupancy and task execution progress of each computing node are collected in real time. For a strongly dependent execution chain formed by strong dependencies, if the actual energy consumption of the computing power node carrying the execution chain exceeds the preset energy consumption constraint threshold, the execution order of the sub-units in the execution chain remains unchanged, and the sub-units in the chain that have not yet been executed are migrated to a computing power node that can adapt to the semantic type of the strongly dependent execution chain, whose energy consumption per unit time does not exceed the preset energy consumption threshold, has the ability to execute continuously without interruption, and whose energy consumption per unit time is lower than the actual energy consumption of the current carrying node. For weakly dependent units, if the actual energy consumption of the computing node carrying the unit exceeds the preset energy consumption constraint threshold, or the node's computing power occupancy rate exceeds the reasonable operating range, the weakly dependent units that have not yet been executed will be migrated to other computing nodes that can adapt to the semantic type of the weakly dependent unit and have a spare range of available computing power.

9. A cloud computing platform AI computing power allocation method considering energy consumption constraints according to claim 1, characterized in that, Based on the timing of data interaction between the two, the steps for weakly dependent units to be executed during the idle computing power period of the corresponding strongly dependent execution chain include: If a weakly dependent unit needs to provide associated input data to a strongly dependent execution chain, then the execution phase of the corresponding data requirement in the strongly dependent execution chain can only be started after the weakly dependent unit has completed its execution. The weakly dependent unit is preferentially scheduled to be executed during the idle computing power period of the corresponding strongly dependent execution chain node. If a weakly dependent unit needs to receive output data from a strongly dependent execution chain, then the execution start point of the weakly dependent unit is set to be after the data output point of the corresponding strongly dependent execution chain.

10. A cloud computing platform AI computing power allocation system considering energy consumption constraints, characterized in that, include: The task parsing module is used to receive AI computing power tasks submitted by users, perform full semantic parsing on the AI ​​computing power tasks, and break them down into multiple sub-units; each sub-unit is the smallest execution segment in the AI ​​computing power task that has independent execution semantics and can complete a single computing objective. The dependency identification module is used to obtain the association relationships between all the sub-units, distinguish strong dependencies from weak dependencies based on the association relationships, and construct a semantic dependency link graph. The strong dependency relationship is that the output of the preceding sub-unit is the only input of the subsequent sub-unit; the weak dependency relationship is that there is only partial data association between sub-units, which can be executed in parallel or have their execution order flexibly adjusted. The strong chain deployment module is used to extract all sub-units connected by strong dependencies to form a strong dependency execution chain; lock the execution order of sub-units within the chain; traverse all computing power nodes that are compatible with the semantic type of the strong dependency execution chain; collect the unit time energy consumption and continuous execution stability data of each computing power node executing the strong dependency execution chain; filter out target computing power nodes with energy consumption values ​​lower than a preset threshold and continuous execution without interruption; and deploy the strong dependency execution chain on the target computing power nodes. The weak-dependency scheduling module is used to obtain the computing power occupancy time sequence of the target computing power nodes and identify the computing power surplus interval of each target computing power node. All sub-units that are only associated by weak dependencies are marked as weak dependency units. Weak dependency units are classified according to semantic type. Weak dependency units of the same type are prioritized to be filled into the computing power surplus range of the corresponding adaptation node for parallel execution. Unfilled weak dependency units are aggregated according to semantic type and deployed to the adaptation computing power node with the lowest energy consumption value for parallel execution. The timing coordination module is used to schedule the weakly dependent unit to be executed during the idle computing time of the corresponding strongly dependent execution chain when there is some data association between the weakly dependent unit and the strongly dependent execution chain.

Images