A computing power intelligent allocation method and service system based on cloud edge collaboration
Patent Information
- Authority / Receiving Office
- CN · China
- Patent Type
- Applications(China)
- Current Assignee / Owner
- BEIJING XINYANG HONGDA TECHNOLOGY CO LTD
- Filing Date
- 2026-04-20
- Publication Date
- 2026-07-14
Smart Images
Figure CN122387665A_ABST
Abstract
Description
Technical Field
[0001] This invention relates to the field of computer technology, and in particular to a method and service system for intelligent allocation of computing power based on cloud-edge collaboration. Background Technology
[0002] With the development of cloud computing and edge computing technologies, multi-node collaborative processing models are gradually being applied to technical environments such as data analysis, real-time computing, and distributed business processing. In such technical environments, computing tasks typically need to be executed in a distributed manner between cloud nodes and multiple edge nodes. Each computing node transmits task data and exchanges processing results through network communication links, thereby forming a cross-node collaborative computing system.
[0003] In existing technical solutions, a common task scheduling method is to allocate tasks to nodes based on the current node load status or historical resource usage. When a task arrives, the scheduling system detects the current available computing power of each computing node and allocates the task to the corresponding node for execution based on the detection results. During task execution, when the node load changes or the task needs to migrate across nodes, the scheduling system reallocates or reschedules the task based on the real-time status.
[0004] However, the inventors of this application discovered in the process of implementing the relevant technical solutions that the above-mentioned prior art has at least the following technical problems: due to the lack of unified organization and time series constraints on the computing power resources of each computing node in the future time period during the distributed task scheduling process, when the computing power status of the node changes during the task execution, the task execution path is prone to mismatch with the actual computing power status of the node, which leads to resource conflicts or execution interruptions during the task execution process. Summary of the Invention
[0005] To overcome the above shortcomings, this invention provides a cloud-edge collaborative intelligent computing power allocation method and service system, aiming to improve the problem that existing technologies are prone to mismatches between task execution paths and the actual computing power status of nodes, leading to resource conflicts or execution interruptions during task execution.
[0006] In a first aspect, the present invention provides the following technical solution: a method for intelligent allocation of computing power based on cloud-edge collaboration, comprising the following steps: S1. Obtain the node status information of cloud nodes and multiple edge nodes in multiple discrete time windows in the future, organize the available computing power of each computing node in the future time window into schedulable and publishable computing power time slice resources, and generate the computing power time slice sequence corresponding to each computing node. S2. Obtain the task to be processed, perform task plasticity decomposition on the task to be processed to obtain multiple sub-tasks, and establish dependencies, execution time limits and time sequence execution constraints for each sub-task. S3. For each subtask, the computing power time slice sequence and subtask requirement information are sent to the candidate edge nodes. Each candidate edge node generates candidate execution time slice information for the corresponding subtask in different time windows based on the local computing power time slice sequence, forming a local negotiation result. S4. The cloud node receives the local negotiation results returned by each candidate edge node, generates the time series execution chain of the subtask based on the subtask dependency, execution time limit, time series execution constraints and computing power time slice sequence of each computing node, determines the target computing node and target time window corresponding to each subtask, and forms the final allocation result. S5. Execute each subtask in the target computing node and target time window according to the final allocation result, and splice the multi-node execution state based on the state snapshot when the subtask is executed across computing nodes. S6. During execution, when the current computing power time slice of the target computing node is insufficient to support the continued execution of the corresponding subtask, the computing power time slice in the future time window is pre-occupied based on the computing power credit of the target computing node to form a borrowed computing power time slice, and the replenishment is performed in the subsequent time window. S7. Based on the execution feedback of each subtask, perform closed-loop correction on the computing power time slice sequence and subtask time sequence execution chain in the subsequent time window, and replace the original final allocation result.
[0007] Preferably, in step S1, the step of generating the computing power time slice sequence corresponding to each computing node includes: Obtain the basic allocatable computing power of each computing node over multiple discrete time windows in the future; Obtain the node reliability parameters and node state fluctuation parameters of each computing node within each discrete time window; Based on the aforementioned basic allocable computing power, node reliability parameters, and node state fluctuation parameters, the effective computing power time slice capacity within each discrete time window is generated. The effective computing power time slice capacity within each discrete time window is arranged in chronological order to form a computing power time slice sequence for the corresponding computing node. The basic allocable computing power is obtained by subtracting the reserved computing power for the node's local inherent services from the node's theoretical total computing power.
[0008] Preferably, in step S2, the step of obtaining the task to be processed and performing task plasticity decomposition on the task to be processed includes: The task to be processed is divided into multiple sub-tasks according to the computational process structure; Establish subtask computational load information, subtask input data scale information, and subtask output data scale information for each subtask; Establish dependencies between subtasks according to the data processing order; Set a maximum allowed completion time for each subtask; Set time-series execution constraints for each subtask based on its execution stage within the overall task.
[0009] Preferably, the step of setting time-series execution constraints for each subtask based on its execution stage within the overall task includes: Each subtask is divided into continuously executed subtasks, delayed executed subtasks, and migrated executed subtasks; Set node switching control parameters for continuously executed subtasks to ensure that the number of computing node switches allowed during execution does not exceed a preset number; Set delayed execution control parameters for delayed execution subtasks so that they can be executed in subsequent time windows, provided that the maximum allowed completion time is met; Set cross-node migration control parameters for the migration execution subtask to allow it to be executed in segments across multiple target compute nodes.
[0010] Preferably, in step S3, the step of generating candidate execution time slice information for the corresponding subtask in different time windows includes: Each candidate edge node receives the subtask requirement information for the corresponding subtask; Each candidate edge node generates candidate execution time slice information for each discrete time window based on its local computing power time slice sequence; Each candidate edge node generates time-connection control parameters based on the data transmission time information and state recovery time information between the computing node where the preceding subtask is located and the current candidate edge node. Based on the candidate execution time slice information and time connection parameters, a local negotiation result is formed and sent to the cloud node.
[0011] Preferably, in step S4, the step of generating the time-series execution chain of the subtask includes: The cloud node aggregates the local negotiation results returned by each candidate edge node; The time-series execution path of the subtask is generated based on the subtask execution time information, node reliability parameters, and node switching impact parameters. Under the conditions of satisfying the subtask completion time constraints, computing node computing power time slice capacity constraints, and dependency order constraints, determine the target computing node and target time window corresponding to each subtask; The determined result is output as the final allocation result.
[0012] Preferably, in step S5, the step of stitching together the execution states of multiple nodes based on state snapshots when a subtask is executed across computing nodes includes: A state snapshot is generated after the subtask completes its execution at the current target computation node. Send the state snapshot to the next target computing node; The next target computing node performs state recovery processing based on the state snapshot; Determine whether the continuous execution condition is met based on the state continuity parameter between the recovered state and the expected state; If the conditions for continuous execution are met, the subsequent subtasks will continue to be executed; otherwise, a state rollback or cloud node takeover will be triggered.
[0013] Preferably, in step S6, the step of pre-occupying computing power time slices within a future time window based on the computing power credit of the target computing node to form a borrowed computing power time slice includes: A computing power credit value is established for each computing node. The computing power credit value is generated based on the node's historical task completion stability, computing power time slice fulfillment consistency, and collaborative execution contribution. When the target computing node has insufficient computing power time slices within the current time window, it is determined whether the computing power credit value meets the borrowing conditions. When the borrowing conditions are met, the target computing node is allowed to pre-occupy a portion of the computing power time slice within a future time window to form a borrowed computing power time slice. The corresponding computing power time slices are reserved in the subsequent time window to complete the replenishment.
[0014] Preferably, in step S7, the step of performing closed-loop correction on the computing power time slice sequence and subtask time sequence execution chain within the subsequent time window based on the execution feedback of each subtask includes: Collect information on the actual execution time, computing time slice occupancy, and node switching of each subtask during the execution process; Based on the execution feedback, update the node reliability parameters and node state fluctuation parameters of each computing node in the subsequent time window; Regenerate the computing power time slice sequence for subsequent time windows based on the updated parameters; Regenerate the time-series execution chain of the subtasks and replace the original final assignment result.
[0015] Secondly, the present invention provides the following technical solution: a cloud-edge collaborative intelligent computing power allocation service system, comprising: The computing power time slice generation module is used to obtain the node status information of cloud nodes and multiple edge nodes in multiple discrete time windows in the future, and generate a computing power time slice sequence for each computing node based on the node status information. The task plasticity modeling module is used to acquire the task to be processed, perform task plasticity decomposition on the task to be processed to obtain multiple sub-tasks, and establish dependencies, execution time limits and migration constraints for each sub-task. The local negotiation module is used to send the computing power time slice sequence and sub-task requirement information to the candidate edge nodes for each sub-task, and each candidate edge node generates a local negotiation result for the corresponding sub-task based on the local available computing power time slice. The global clearing module receives the local negotiation results returned by each candidate edge node, combines the dependencies, execution time limits, migration constraints of each subtask, and computing power time slice sequences of each computing node to perform global clearing, determine the target computing node and target time window corresponding to each subtask, and generate the final allocation result. The execution control module is used to execute each subtask in the target computing node and target time window according to the final allocation result, and to perform multi-node execution state splicing when the subtask is executed across computing nodes. The credit borrowing module is used to borrow computing power credit based on the computing power credit of the target computing node when the current computing power time slice of the target computing node is insufficient to support the continued execution of the corresponding subtask during the execution process, and replenish it in the subsequent time window; The closed-loop correction module is used to perform closed-loop correction on the computing power time slice sequence, local negotiation results and final allocation results in subsequent time windows based on the execution feedback of each subtask.
[0016] The present invention has the following beneficial effects: 1. This invention organizes the available computing power of each computing node into a computing power time slice sequence within multiple discrete time windows in the future, and generates a time sequence execution chain based on the sub-task dependency relationship. This realizes unified scheduling and constraint control of distributed computing power resources in the time dimension, thereby avoiding scheduling mismatch, resource utilization conflict and execution interruption problems caused by changes in the computing power status of nodes during task scheduling in the prior art.
[0017] 2. This invention introduces a state snapshot generation and multi-node execution state splicing mechanism during task execution, enabling subtasks to complete state recovery processing based on a unified execution context when migrating across computing nodes. This ensures execution consistency during the segmented execution of subtasks, thereby reducing redundant calculations or task rollbacks caused by state discontinuity during node migration and improving the stability of distributed task execution.
[0018] 3. This invention establishes a computing power credit borrowing and replenishment scheduling mechanism, and combines execution feedback to perform closed-loop correction of the computing power time slice sequence and time sequence execution chain. This enables the system to dynamically adjust subsequent scheduling strategies according to the actual operating status of nodes, and can maintain the continuous progress of task execution process even in the event of short-term computing power shortage or node status fluctuations, thereby enhancing the system's resource coordination capability under multi-node collaborative operation conditions. Attached Figure Description
[0019] Figure 1 This is a flowchart of a cloud-edge collaborative intelligent computing power allocation method proposed in this invention. Figure 2 This is a system architecture diagram of a cloud-edge collaborative intelligent computing power allocation service proposed in this invention. Detailed Implementation
[0020] The technical solutions in the embodiments of the present invention will be clearly and completely described below with reference to the accompanying drawings. Obviously, the described embodiments are only some embodiments of the present invention, and not all embodiments. Based on the embodiments of the present invention, all other embodiments obtained by those skilled in the art without creative effort are within the scope of protection of the present invention.
[0021] Example 1: Refer to Figure 1 In the first embodiment of the present invention, the present invention provides a method and service system for intelligent allocation of computing power based on cloud-edge collaboration, including the following steps: S1. Obtain the node status information of cloud nodes and multiple edge nodes in multiple discrete time windows in the future, organize the available computing power of each computing node in the future time window into schedulable and publishable computing power time slice resources, and generate the computing power time slice sequence corresponding to each computing node. S2. Obtain the task to be processed, perform task plasticity decomposition on the task to be processed to obtain multiple sub-tasks, and establish dependencies, execution time limits and time sequence execution constraints for each sub-task. S3. For each subtask, the computing power time slice sequence and subtask requirement information are sent to the candidate edge nodes. Each candidate edge node generates candidate execution time slice information for the corresponding subtask in different time windows based on the local computing power time slice sequence, forming a local negotiation result. S4. The cloud node receives the local negotiation results returned by each candidate edge node, generates the time series execution chain of the subtask based on the subtask dependency, execution time limit, time series execution constraints and computing power time slice sequence of each computing node, determines the target computing node and target time window corresponding to each subtask, and forms the final allocation result. S5. Execute each subtask in the target computing node and target time window according to the final allocation result, and splice the multi-node execution state based on the state snapshot when the subtask is executed across computing nodes. S6. During execution, when the current computing power time slice of the target computing node is insufficient to support the continued execution of the corresponding subtask, the computing power time slice in the future time window is pre-occupied based on the computing power credit of the target computing node to form a borrowed computing power time slice, and the replenishment is performed in the subsequent time window. S7. Based on the execution feedback of each subtask, perform closed-loop correction on the computing power time slice sequence and subtask time sequence execution chain in the subsequent time window, and replace the original final allocation result.
[0022] Specifically, in this embodiment, the method operates in a distributed computing environment consisting of cloud nodes and multiple edge nodes. Cloud nodes manage the execution paths of each subtask and generate the final allocation results, while edge nodes provide computing power and execute subtasks. Nodes interact with each other via network communication links for data exchange and control information transmission. During operation, the system uses a pre-defined discrete time window as the basic cycle for computing power scheduling, uniformly organizing the available computing power of each computing node within a future time period, thus forming a time-series-oriented representation of computing resources.
[0023] In step S1, the system first collects the node status information of each computing node. This node status information includes the node's theoretical computing power, current computing task occupancy, node operational stability, and node load changes. Based on this information, the system determines the basic computing power that each computing node can provide in multiple discrete time windows in the future, and processes the node operational stability and node load changes to obtain the effective computing power capacity within each time window. Subsequently, the effective computing power capacity within each time window is arranged in chronological order to form a computing power time slice sequence for the corresponding computing node, allowing the computing power resources that the node can participate in scheduling in the future to be expressed in a time-series manner.
[0024] In step S2, the system acquires the task to be processed and performs structural parsing on it. Based on the internal data processing flow and computational dependencies, the task is divided into multiple subtasks. Computational requirements and input / output data scale information are established for each subtask, and dependencies between subtasks are established according to the data processing order. A maximum allowed completion time is set for each subtask to limit its completion range during scheduling. The system sets time-series execution constraints based on the execution stage of each subtask within the overall task to determine the execution mode of each subtask across different time windows and computational nodes.
[0025] In step S3, after receiving the subtask requirement information, each candidate edge node reads its local computing power time slice sequence and generates candidate execution time slice information based on its available computing power in different time windows. When a subtask needs to be executed in segments across different computing nodes, the system generates time-sequence control parameters based on the data transmission time between the node containing the preceding subtask and the current candidate node, as well as the time required for state recovery. Each candidate edge node combines the candidate execution time slice information with the time-sequence control parameters to form a local negotiation result, which is then sent to the cloud node.
[0026] In step S4, the cloud node summarizes the local negotiation results returned by each candidate edge node. Based on the dependencies between subtasks, the execution time limits of each subtask, and time-series execution constraints, the cloud node uniformly filters and combines the computing power time slices provided by different nodes within different time windows, thereby generating the time-series execution chain for each subtask. By comprehensively judging the execution time range, computing power capacity range, and execution order constraints, the target computing node and its target execution time window for each subtask are determined, and the final allocation result is output.
[0027] In step S5, each target computing node executes subtask processing based on the final allocation result. When a subtask needs to be migrated from the current computing node to another computing node for continued execution, the current node generates a state snapshot after completing the subtask phase and sends the state snapshot to the next target computing node. The next target computing node performs state recovery processing based on the state snapshot and compares the recovered state with the expected state to determine whether the continuous execution condition is met. When the continuous execution condition is met, subsequent subtask processing continues; when the continuous execution condition is not met, the system triggers state rollback processing or the cloud node takes over the execution.
[0028] In step S6, when the target computing node's computing power time slice within the current time window is insufficient to support the continued execution of the corresponding subtask, the system generates a computing power credit value based on the node's historical task execution stability and computing power fulfillment status. If the computing power credit value meets the preset borrowing conditions, the target computing node is allowed to pre-occupy a portion of the computing power time slice within a future time window to form a borrowed computing power time slice. The borrowed computing power time slice is used for the execution of the current subtask and is replenished in subsequent time windows through reserved computing power.
[0029] In step S7, the system continuously monitors the execution process of each subtask, collecting information on actual execution time, computing power time slice occupancy, and node switching. Based on the execution feedback, it updates the node stability and load changes of each computing node in subsequent time windows, and regenerates the computing power time slice sequence for subsequent time windows accordingly. Simultaneously, it reconstructs the time-series execution chain of the subtasks based on the updated computing power time slice sequence, replacing the original final allocation result with the newly generated execution chain, thereby achieving closed-loop adjustment of the method's execution process.
[0030] Furthermore, in step S1, the step of generating the computing power time slice sequence corresponding to each computing node includes: Obtain the basic allocatable computing power of each computing node over multiple discrete time windows in the future; Obtain the node reliability parameters and node state fluctuation parameters of each computing node within each discrete time window; The effective computing power time slice capacity within each discrete time window is generated based on the basic allocable computing power, node reliability parameters, and node state fluctuation parameters. The effective computing power time slice capacity within each discrete time window is arranged in chronological order to form a computing power time slice sequence for the corresponding computing node. The basic allocable computing power is obtained by subtracting the reserved computing power for the node's local inherent business from the node's theoretical total computing power.
[0031] Specifically, each computing node discretly divides future scheduling cycles according to a unified time base within the system's runtime, resulting in multiple consecutive time windows. Each time window corresponds to a scheduling granularity unit, and each node independently evaluates its computing capacity to participate in distributed task processing within each time window. Node status information is collected through the node's local monitoring module, including runtime status data such as processor utilization, task queue length, memory usage ratio, and network link stability, and is updated before the start of each time window.
[0032] For any computing node, the basic allocable computing power within any time window is determined according to the following relationship: ; in, This represents the basic allocable computing power of the i-th computing node within the time window t; This represents the theoretical total computing power of the computing node; This indicates the computing power capacity reserved for local task processing on the node within the time window t.
[0033] Node reliability parameters characterize the stability of a computing node when executing external distributed tasks within a corresponding time window. They are calculated based on changes in the node's operational state over consecutive time windows. Specifically, node stability indices are generated by statistically analyzing the number of task execution interruptions and runtime of the node in the previous scheduling cycle, and then the node reliability parameters are generated according to a preset mapping relationship. ,in, The value range is from 0 to 1.
[0034] Node state fluctuation parameters reflect the magnitude of load changes on a node within a corresponding time window. The system calculates these parameters by comprehensively analyzing changes in node processor utilization and task queue length. When the node load fluctuates little, this parameter takes a lower value; when the node load changes significantly, this parameter takes a higher value.
[0035] After obtaining the basic allocable computing power, node reliability parameters, and node state fluctuation parameters, the system generates the effective computing power time slice capacity of the node within the time window according to the following relationship: ; in, This represents the effective computing power time slice capacity of the i-th computing node within the time window t; This represents the basic allocable computing power; Indicates node reliability parameters; This represents the node state fluctuation parameter.
[0036] The above method converts the node's effective computing power over multiple future time windows into a set of computing power time slice capacity values arranged in chronological order, forming a computing power time slice sequence for the node. This computing power time slice sequence is stored in the node's local scheduling unit and synchronously sent to the cloud node's scheduling management module for subsequent task allocation decisions.
[0037] After generating the computing power time slice sequence, the system updates the node reliability parameters and node state fluctuation parameters at the end of each scheduling cycle based on the actual task execution status of the nodes, thereby dynamically adjusting the computing power time slice capacity in subsequent time windows.
[0038] Through the above-mentioned computing power time slice generation process, the available computing power of each computing node in the future scheduling cycle is uniformly expressed in the form of time series, so that the task allocation process can be carried out under the condition of meeting the node capacity constraints, thereby realizing the controllable scheduling of distributed computing resources in the time dimension.
[0039] Furthermore, in step S2, the steps of obtaining the task to be processed and performing task plasticity decomposition on the task to be processed include: The task to be processed is divided into multiple sub-tasks according to the computational process structure; Establish subtask computational load information, subtask input data scale information, and subtask output data scale information for each subtask. Establish dependencies between subtasks according to the data processing order; Set a maximum allowed completion time for each subtask; Set time-series execution constraints for each subtask based on its execution stage within the overall task.
[0040] The steps for setting time-series execution constraints for each subtask based on its execution stage within the overall task include: Each subtask is divided into continuously executed subtasks, delayed executed subtasks, and migrated executed subtasks. Set node switching control parameters for continuously executed subtasks to ensure that the number of computing node switches allowed during execution does not exceed a preset number; Set delayed execution control parameters for delayed execution subtasks so that they can be executed in subsequent time windows, provided that the maximum allowed completion time is met; Set cross-node migration control parameters for the migration execution subtask to allow it to be executed in segments across multiple target compute nodes.
[0041] Specifically, after receiving a task to be processed, the system first performs a structured decomposition of the task's processing flow through a task parsing unit. Based on the data processing stages involved, the task parsing unit divides the task into several sub-task units with independent processing functions. Each sub-task unit corresponds to a computational stage in the task processing flow and has clearly defined input data, processing logic, and output results. After the sub-tasks are divided, the system establishes computational requirement description information for each sub-task, which is used for computing power matching during subsequent scheduling.
[0042] For any subtask, its computational requirements are determined according to the following relationship: ; in, This represents the computational requirement of the k-th subtask; This indicates the number of computational units required for this subtask; This represents the computational complexity coefficient corresponding to a single computational unit.
[0043] While determining the computational requirements of the subtasks, the system records the scale of the input data for each subtask. With output data size The input data size is used to evaluate the data transfer overhead required when migrating subtasks between different computing nodes, while the output data size is used to establish the input relationships for subsequent subtasks.
[0044] Subsequently, the system establishes dependencies between subtasks based on the data processing order within each task. If the subtasks... Execution depends on subtasks The output result then limits the subtasks during the scheduling process. The execution time of the task must not be earlier than that of the subtask. The completion time. This dependency is stored in a task dependency table and serves as one of the constraints for generating the time-series execution chain.
[0045] After establishing dependencies, the system sets a maximum allowed completion time for each subtask. This parameter limits the latest completion time of subtasks within the scheduling cycle, ensuring that the overall task can be completed within the preset time frame. The maximum allowed completion time is determined through the task attribute configuration module and can be adjusted based on task priority and business processing requirements.
[0046] During the time-series execution constraint formation process, the system categorizes subtasks into different execution categories based on their position within the overall task and the requirement for execution continuity. For continuously executed subtasks, the system generates node switching control parameters. This parameter limits the number of node migrations allowed during the execution of a subtask. When the number of node switches reaches the preset limit, the subtask must complete its subsequent processing on the current computing node. For deferred execution subtasks, the system generates deferred execution control parameters. This parameter is used to limit the scheduling order of subtasks across multiple time windows. When computing resources are insufficient in the current time window, the scheduling unit may postpone the execution of the subtask to a subsequent time window, but its completion time must not exceed the maximum allowed completion time.
[0047] For the migration execution subtask, the system generates cross-node migration control parameters. This describes the migration capability of a subtask between different computing nodes. The migration control parameters are combined with the input data size. The system sets the communication bandwidth information between nodes to control the granularity of segmented scheduling during subtask execution. After completing the above task plasticity decomposition and execution constraint modeling, the system forms a set of subtask execution characteristic descriptions, which serve as important input information for subsequent computing power matching and scheduling decisions. By uniformly modeling the computational requirements, dependencies, execution time limits, and time-series execution constraints of subtasks, the scheduling process can perform distributed segmented execution of each subtask while satisfying the task execution logic, thereby achieving collaborative processing of tasks under multi-node and multi-time-window conditions.
[0048] Furthermore, in step S3, the step of generating candidate execution time slice information for the corresponding subtask in different time windows includes: Each candidate edge node receives the subtask requirement information for the corresponding subtask; Each candidate edge node generates candidate execution time slice information for each discrete time window based on its local computing power time slice sequence; Each candidate edge node generates time-connection control parameters based on the data transmission time information and state recovery time information between the computing node where the preceding subtask is located and the current candidate edge node. A local negotiation result is generated based on the candidate execution time slice information and time connection parameters and sent to the cloud node.
[0049] Specifically, when the system executes step S3, the cloud node sends the task description information of the subtask to be scheduled to multiple candidate edge nodes. The task description information includes the subtask's computational requirements, the subtask's input data size, the subtask's output data size, the maximum allowed completion time, and time-series execution constraint parameters. After receiving the subtask requirement information, the candidate edge nodes first read the corresponding computing power time slice sequence through their local scheduling management unit, and then search for time slice resources that can meet the subtask's execution conditions within their local time window.
[0050] Within each discrete time window, edge nodes generate candidate execution time slice information based on the relationship between their local available computing power time slice capacity and the computational requirements of the subtask. If the available computing power time slice capacity within a time window can meet the computational requirements of the subtask, then that time window is marked as an executable time slice. For any candidate edge node, the execution time required to execute subtask k within time window t is determined according to the following relationship: ; in, This represents the execution time required for the i-th candidate edge node to execute subtask k within the time window t; This represents the computational requirement of subtask k; This represents the effective computing power time slice capacity of the i-th edge node within the time window t.
[0051] When the calculated execution time is less than or equal to the allowed execution duration of the time window, the time window is recorded as a candidate execution time slice, and corresponding candidate execution time slice information is generated. The candidate execution time slice information includes the time window number, allocable computing power capacity, and estimated execution time. After generating the candidate execution time slice information, the system further calculates the time-connection control parameters generated when subtasks are executed across nodes. For subtasks that need to migrate between different computing nodes, the data transfer time and state recovery time between nodes will directly affect the actual start execution time of the subtask. The time-connection control parameters are generated according to the following relationship: ; in, This represents the timing transition control parameter when a subtask migrates from the i-th computing node to the j-th computing node; This represents the data transmission time between node i and node j; This represents the processing time required for node j to complete state recovery after receiving the state snapshot.
[0052] Data transmission time is calculated based on the bandwidth of the inter-node communication link and the size of the subtask input data. State recovery time is determined by the processing time required for the node's local execution environment to load and initialize the state data. After obtaining candidate execution time slice information and time-series control parameters, each candidate edge node combines this information to form a local negotiation result. The local negotiation result includes the node identifier, candidate execution time window, the allocable computing power time slice capacity within the corresponding time window, and the corresponding time-series control parameters. The local negotiation result is sent to the cloud node via the network communication interface for subsequent generation of the time-series execution chain of the subtask.
[0053] Through the aforementioned local negotiation process, each candidate edge node provides executable time window information under the constraints of local computing power time slices, and reports the time connection control parameters required for cross-node execution together, thereby providing basic data for cloud nodes to perform global task scheduling, so that the subsequently generated time series execution chain can simultaneously meet the computing power constraints and the inter-node connection constraints.
[0054] Furthermore, in step S4, the step of generating the time-series execution chain of the subtasks includes: The cloud node aggregates the local negotiation results returned by each candidate edge node; The time-series execution path of the subtask is generated based on the subtask execution time information, node reliability parameters, and node switching impact parameters. Under the conditions of satisfying the subtask completion time constraints, computing node computing power time slice capacity constraints, and dependency order constraints, determine the target computing node and target time window corresponding to each subtask; The determined result will be output as the final allocation result.
[0055] Specifically, when the system enters step S4, the cloud node's scheduling and management unit first receives and organizes the local negotiation results from each candidate edge node. The local negotiation results are categorized and stored according to the subtask identifier, and a set of executable time slices for each subtask is constructed based on the order of the candidate execution time windows. Each set of candidate execution time slices contains information such as the executable node number, the executable time window number, the corresponding computing power time slice capacity, and time connection control parameters.
[0056] After forming a set of candidate execution time slices, the cloud node uniformly calculates the execution time of each subtask on different computing nodes. The execution duration of any subtask within a certain time window on a given computing node is determined according to the following relationship: ; in, This represents the execution duration of subtask k within the time window t of the i-th computation node; This represents the computational requirement of subtask k; This represents the effective processing capacity of the i-th computing node within the time window t for executing the subtask.
[0057] After obtaining the execution duration, the cloud node further filters candidate execution paths by incorporating node reliability parameters. Node reliability parameters characterize a node's ability to maintain stable operation within a continuous time window. For nodes with low reliability, the scheduling management unit lowers their priority when constructing execution paths, thereby reducing the risk of interruption due to node state changes during task execution. When a subtask needs to migrate across nodes, the system also considers node switching impact parameters. These parameters are jointly determined by time-coordinated control parameters and node switching frequency control parameters, characterizing the additional time cost required for task migration between different nodes. By comprehensively calculating the execution duration and node switching impact parameters, the cloud node generates time-series execution paths for subtasks in chronological order.
[0058] During the generation of execution paths, the system must satisfy several constraints. First, the completion time of a subtask must meet the maximum allowed completion time constraint, meaning the final completion time of a subtask must not exceed its preset completion time limit. Second, the sum of the computing time slices allocated to multiple subtasks by each computing node within the same time window must not exceed the effective computing time slice capacity of that node within that time window. Third, the execution order between subtasks must conform to dependency constraints; the start execution time of a subsequent subtask must not be earlier than the completion time of the preceding subtask and its corresponding time connection control parameters.
[0059] If the above constraints are met, the cloud node determines the target computing node and target time window for each subtask, and records the allocation result as the final allocation result. The final allocation result includes information such as the subtask number, the target execution node number, the target execution time window, and the expected execution duration.
[0060] Through the aforementioned global clearing process, cloud nodes can generate time-series execution chains that conform to task execution logic under multi-node and multi-time-window conditions, enabling each subtask to complete distributed execution under the premise of meeting computing capacity constraints and execution order constraints, thereby achieving unified scheduling of computing resources within the system.
[0061] Furthermore, in step S5, the step of stitching together the execution states of multiple nodes based on state snapshots when a subtask is executed across computing nodes includes: A state snapshot is generated after the subtask completes its execution at the current target computation node. Send the state snapshot to the next target compute node; The next target computing node performs state recovery processing based on the state snapshot; Determine whether the continuous execution condition is met based on the state continuity parameter between the recovered state and the expected state; If the conditions for continuous execution are met, the subsequent subtasks will continue to be executed; otherwise, a state rollback or cloud node takeover will be triggered.
[0062] Specifically, during the segmented execution of subtasks across multiple computing nodes according to a time-series execution chain, the system generates state snapshot data at the end of each execution phase. The state snapshot is generated by the execution control module of the current computing node and includes information such as the intermediate computation results of the subtask, the current execution progress indicator, runtime context parameters, and the remaining computational requirements of the subtask. The state snapshot is sent to the next target computing node via the inter-node communication interface and is received and stored by the state management unit of the next node after transmission.
[0063] During the state recovery phase, the next target compute node initializes its local execution environment based on the received state snapshot data. The initialization process includes loading intermediate computation results, restoring the execution progress flag, and rebuilding the runtime context parameters, enabling subtasks to continue executing the remaining computation process on the new compute node. To ensure the consistency of task states during cross-node execution, the system performs a consistency check between the restored state and the expected state after state recovery is complete. State continuity is determined by the following relationship: ; in, This represents the deviation in the state continuity of the k-th subtask after node migration; This represents the state value after the next target calculation node completes state recovery; This represents the expected state value derived from the execution chain based on the time series.
[0064] The system presets a state continuity judgment threshold. When the state continuity deviation is less than or equal to the threshold, the state recovery process is considered to meet the continuous execution condition, and the subtask can continue to execute the remaining computation process on the new computing node. When the state continuity deviation exceeds the threshold, the system executes an exception handling procedure. The exception handling procedure includes performing a state rollback operation on the current node or having the cloud node scheduling and management module take over the subsequent execution of the subtask. During execution, the system simultaneously records the state snapshot generation time and state recovery time of each node, and uses this time information to update the time connection control parameters in the subsequent time window, thereby ensuring that the execution delay caused by node migration can be accurately reflected in the subsequent subtask scheduling process.
[0065] Through the above multi-node execution state splicing process, the system can maintain the continuity of task execution state when subtasks are executed across nodes, so that the segmented execution process of subtasks across different computing nodes has a consistent running context, thereby ensuring the continuous advancement of the overall task processing flow in the time-series execution chain.
[0066] Furthermore, in step S6, the step of pre-occupying computing power time slices within a future time window based on the computing power credit of the target computing node to form a borrowed computing power time slice includes: A computing power credit value is established for each computing node. The computing power credit value is generated based on the node's historical task completion stability, computing power time slice fulfillment consistency, and collaborative execution contribution. When the target computing node has insufficient computing power time slices in the current time window, it is determined whether the computing power credit value meets the borrowing conditions. When the borrowing conditions are met, the target computing node is allowed to pre-occupy a portion of the computing power time slice within a future time window to form a borrowed computing power time slice. The corresponding computing power time slices are reserved in the subsequent time window to complete the replenishment.
[0067] Specifically, during system operation, each computing node establishes a computing power credit management unit to statistically record and track the node's task execution performance within historical scheduling cycles. The stability of a node's historical task completion is obtained by statistically analyzing the proportion of sub-tasks successfully completed by the node across multiple scheduling cycles. The consistency of computing power time slice fulfillment is calculated by the difference between the actual computing power time slice capacity provided by the node and the computing power time slice capacity promised during the scheduling phase. The contribution to collaborative execution is obtained by statistically analyzing the number of times the node participates in distributed execution tasks and the execution duration. Based on these three types of operational data, the system generates a corresponding computing power credit value for each computing node.
[0068] Within any time window, when a target computing node detects that its current remaining computing power time slice capacity is insufficient to support the continued execution of a subtask, the node scheduling control unit sends a borrowing request to the computing power credit management unit. The system compares the node's current computing power credit value with a preset borrowing threshold to determine if the node meets the conditions for pre-occupying future computing power time slices. If the borrowing conditions are met, the system allows the node to pre-occupy a portion of the computing power time slices within the future time window, provided it does not violate the future time window's computing power capacity constraints. The borrowed computing power time slice capacity is determined according to the following relationship: ; in, This represents the computing power time slice capacity that the i-th computing node can borrow within the current time window t; This represents the computing power credit value of the i-th computing node; This indicates the effective computing power time slice capacity of the node in the next time window.
[0069] After determining the borrowed computing power time slice capacity, the system merges this borrowed capacity with the available computing power time slice capacity within the current time window to support the continuous execution of subtasks. Simultaneously, a replenishment flag is reserved for this borrowed capacity in the computing power time slice sequence of future time windows, allowing for priority deduction of the corresponding computing power time slice capacity during subsequent scheduling to replenish the borrowed computing power time slice. During the replenishment process, the node scheduling control unit reduces the computing power time slice capacity available for external distributed task scheduling within the corresponding time window according to the task execution arrangement in the time sequence execution chain, and records the reduced capacity as the borrowed computing power replenishment amount. This replenishment operation continues until the borrowed computing power time slice capacity is completely offset.
[0070] Through the aforementioned computing power credit borrowing and replenishment mechanism, in the event of a short-term shortage of computing power at a node, the system can ensure the continuity of the subtask execution process through computing power coordination between time windows, so that task execution scheduling can maintain stable progress under the condition of meeting computing power capacity constraints.
[0071] Furthermore, in step S7, the step of performing closed-loop correction on the computing power time slice sequence and subtask time sequence execution chain within the subsequent time window based on the execution feedback of each subtask includes: Collect information on the actual execution time, computing time slice occupancy, and node switching of each subtask during the execution process; The node reliability parameters and node state fluctuation parameters of each computing node are updated based on the execution feedback in subsequent time windows. Regenerate the computing power time slice sequence for subsequent time windows based on the updated parameters; Regenerate the time-series execution chain of the subtasks and replace the original final assignment result.
[0072] Specifically, during the execution of subtasks, each computing node monitors the execution process in real time through its local execution record module and uploads the execution feedback information to the cloud node scheduling and management unit. The execution feedback information includes the subtask's actual start time, actual completion time, the computing time slice capacity used during execution, and the number of migrations the subtask made between different computing nodes. This feedback information is compiled at the end of each scheduling cycle and used as the basis for subsequent scheduling adjustments.
[0073] The system first assesses node operational stability based on the difference between actual execution time and planned execution time. The update of node reliability parameters is determined through the following relationship: ; in, This represents the node reliability parameter of the i-th computing node after the update in time window t; This represents the node reliability parameters before the update; This represents the difference between the actual execution time and the planned execution time of the node within the specified time window. This indicates the planned execution time of the node within this time window.
[0074] Simultaneously, the system updates the node state fluctuation parameters based on changes in computing power time slice occupancy during node execution. If a node experiences significant fluctuations in computing power occupancy during execution, its state fluctuation parameters are increased in subsequent time windows, thereby reducing the node's available computing power capacity for distributed scheduling when the computing power time slice sequence is regenerated. After obtaining the updated node reliability parameters and node state fluctuation parameters, the system recalculates the effective computing power time slice capacity for each computing node in subsequent time windows and reconstructs the computing power time slice sequence accordingly. The reconstructed computing power time slice sequence is input as a new resource constraint to the cloud node scheduling and management unit.
[0075] Subsequently, the system regenerates the time-series execution chain of subtasks based on the updated computing power time-slice sequence. When generating the new execution chain, subtasks that have not yet been completed are given priority, and time windows affected by node state changes in the original execution path are reallocated. The final generated execution chain replaces the original allocation result and takes effect in subsequent scheduling cycles.
[0076] Through the above closed-loop correction process, the system can dynamically adjust the node resource status based on actual execution feedback, so that the allocation of computing power time slices in the subsequent scheduling process is more in line with the real-time operation of the nodes, thereby ensuring the stable progress of task execution in continuous scheduling cycles.
[0077] Example 2: Refer to Figure 2 In a second embodiment of the present invention, the present invention provides a cloud-edge collaborative intelligent computing power allocation service system, comprising: The computing power time slice generation module is used to obtain the node status information of cloud nodes and multiple edge nodes in multiple discrete time windows in the future, and generate the computing power time slice sequence corresponding to each computing node based on the node status information. The Task Plasticity Modeling Module is used to acquire tasks to be processed, perform task plasticity decomposition on the tasks to be processed to obtain multiple sub-tasks, and establish dependencies, execution time limits and migration constraints for each sub-task. The local negotiation module is used to send the computing power time slice sequence and subtask requirement information to the candidate edge nodes for each subtask. Each candidate edge node generates a local negotiation result for the corresponding subtask based on the local available computing power time slice. The global clearing module receives the local negotiation results returned by each candidate edge node, combines the dependencies, execution time limits, migration constraints of each subtask, and computing power time slice sequences of each computing node to perform global clearing, determine the target computing node and target time window corresponding to each subtask, and generate the final allocation result. The execution control module is used to execute each subtask in the target computing node and target time window according to the final allocation result, and to perform multi-node execution status splicing when the subtask is executed across computing nodes. The credit borrowing module is used to borrow computing power credit based on the computing power credit of the target computing node when the current computing power time slice of the target computing node is insufficient to support the continued execution of the corresponding subtask during the execution process, and replenish it in the subsequent time window; The closed-loop correction module is used to perform closed-loop correction on the computing power time slice sequence, local negotiation results and final allocation results in subsequent time windows based on the execution feedback of each subtask.
[0078] Specifically, the computing power time slice generation module acquires node status information for each computing node within multiple discrete time windows at the start of the system's runtime cycle. This node status information includes processor resource utilization, task queue status, memory resource usage, and network communication status. Based on the collected node status information, the computing power time slice generation module evaluates the scheduling capability of each computing node within the future time windows and generates a corresponding computing power time slice sequence. The generated computing power time slice sequence characterizes the computing resources that each computing node can provide in subsequent scheduling cycles and serves as a crucial basis for task scheduling.
[0079] The task plasticity modeling module is used to perform structural analysis on tasks after the system receives them. Based on the task's internal data processing flow, the module divides the task into multiple subtasks and establishes execution dependencies between them. This module also sets execution time limits for each subtask and configures migration constraints based on its processing stage within the overall task, thus forming a complete subtask execution model. The results of task plasticity modeling are used to guide subsequent computing power matching and task scheduling processes.
[0080] The local negotiation module sends the subtask execution requirements and computing power time slice sequence to multiple candidate edge nodes after the subtask execution requirements are generated. Each candidate edge node evaluates the feasibility of executing the subtask within different time windows based on its local computing power time slice sequence and generates corresponding candidate execution time slice information. The local negotiation module organizes the information returned by each candidate edge node to form a local negotiation result, and then transmits the result to the global clearing module of the cloud node.
[0081] The global clearing module, upon receiving the local negotiation results, performs a unified screening of the execution paths for each subtask across different computing nodes. Combining subtask dependencies, execution time limits, and migration constraints, the global clearing module comprehensively analyzes the computing power time slice capacity of each computing node within different time windows, thereby determining the target execution node and target execution time window for each subtask. The final scheduling result is output in the form of an execution chain and transmitted to the execution control module.
[0082] The execution control module executes each subtask within the corresponding computing node and time window based on the final allocation result generated by the global clearing module. During subtask execution, when segmented processing is required across multiple computing nodes, the execution control module generates a state snapshot on the current node and sends it to the next node. The next node initializes its execution environment based on the state snapshot, thereby enabling continuous execution of subtasks across different nodes.
[0083] The credit borrowing module monitors the computing power time slice usage of target computing nodes during execution. When it detects that the computing power time slices within the current time window are insufficient to support the continued execution of subtasks, the credit borrowing module generates a computing power credit value based on the node's historical execution records and determines whether the node is eligible to borrow future computing power time slices. If the borrowing conditions are met, the credit borrowing module allows the target computing node to pre-occupy a portion of the computing power time slices within a future time window to ensure the continuity of subtask execution. Simultaneously, it manages the replenishment of borrowed computing power in subsequent scheduling cycles.
[0084] The closed-loop correction module collects execution feedback information after each subtask is completed. This feedback includes the actual execution time of the subtask, the actual occupancy of computing time slices, and node migration status. Based on this feedback, the module updates the status parameters of each computing node and regenerates the computing time slice sequence for subsequent time windows. Simultaneously, this module reconstructs the execution chain for subtasks that have not yet been completed and replaces the original scheduling results, thereby achieving continuous adjustment and resource reallocation during system operation.
[0085] Through the coordinated operation of the above modules, the intelligent computing power allocation service system in this embodiment can dynamically organize and schedule computing resources in a distributed computing environment, enabling tasks to be processed in a preset execution order under multiple nodes and multiple time windows.
[0086] Finally, it should be noted that the above description is only a preferred embodiment of the present invention and is not intended to limit the present invention. Although the present invention has been described in detail with reference to the foregoing embodiments, those skilled in the art can still modify the technical solutions described in the foregoing embodiments or make equivalent substitutions for some of the technical features. Any modifications, equivalent substitutions, improvements, etc., made within the spirit and principles of the present invention should be included within the protection scope of the present invention.
Claims
1. A method for intelligent allocation of computing power based on cloud-edge collaboration, characterized in that, Includes the following steps: S1. Obtain the node status information of cloud nodes and multiple edge nodes in multiple discrete time windows in the future, organize the available computing power of each computing node in the future time window into schedulable and publishable computing power time slice resources, and generate the computing power time slice sequence corresponding to each computing node. S2. Obtain the task to be processed, perform task plasticity decomposition on the task to be processed to obtain multiple sub-tasks, and establish dependencies, execution time limits and time sequence execution constraints for each sub-task. S3. For each subtask, the computing power time slice sequence and subtask requirement information are sent to the candidate edge nodes. Each candidate edge node generates candidate execution time slice information for the corresponding subtask in different time windows based on the local computing power time slice sequence, forming a local negotiation result. S4. The cloud node receives the local negotiation results returned by each candidate edge node, generates the time series execution chain of the subtask based on the subtask dependency, execution time limit, time series execution constraints and computing power time slice sequence of each computing node, determines the target computing node and target time window corresponding to each subtask, and forms the final allocation result. S5. Execute each subtask in the target computing node and target time window according to the final allocation result, and splice the multi-node execution state based on the state snapshot when the subtask is executed across computing nodes. S6. During execution, when the current computing power time slice of the target computing node is insufficient to support the continued execution of the corresponding subtask, the computing power time slice in the future time window is pre-occupied based on the computing power credit of the target computing node to form a borrowed computing power time slice, and the replenishment is performed in the subsequent time window. S7. Based on the execution feedback of each subtask, perform closed-loop correction on the computing power time slice sequence and subtask time sequence execution chain in the subsequent time window, and replace the original final allocation result.
2. The intelligent computing power allocation method based on cloud-edge collaboration according to claim 1, characterized in that, In step S1, the step of generating the computing power time slice sequence corresponding to each computing node includes: Obtain the basic allocatable computing power of each computing node over multiple discrete time windows in the future; Obtain the node reliability parameters and node state fluctuation parameters of each computing node within each discrete time window; Based on the aforementioned basic allocable computing power, node reliability parameters, and node state fluctuation parameters, the effective computing power time slice capacity within each discrete time window is generated. The effective computing power time slice capacity within each discrete time window is arranged in chronological order to form a computing power time slice sequence for the corresponding computing node. The basic allocable computing power is obtained by subtracting the reserved computing power for the node's local inherent services from the node's theoretical total computing power.
3. The intelligent computing power allocation method based on cloud-edge collaboration according to claim 1, characterized in that, In step S2, the steps of obtaining the task to be processed and performing task plasticity decomposition on the task to be processed include: The task to be processed is divided into multiple sub-tasks according to the computational process structure; Establish subtask computational load information, subtask input data scale information, and subtask output data scale information for each subtask. Establish dependencies between subtasks according to the data processing order; Set a maximum allowed completion time for each subtask; Set time-series execution constraints for each subtask based on its execution stage within the overall task.
4. The intelligent computing power allocation method based on cloud-edge collaboration according to claim 3, characterized in that, The step of setting time-series execution constraints for each subtask based on its execution stage within the overall task includes: Each subtask is divided into continuously executed subtasks, delayed executed subtasks, and migrated executed subtasks; Set node switching control parameters for continuously executed subtasks to ensure that the number of computing node switches allowed during execution does not exceed a preset number; Set delayed execution control parameters for delayed execution subtasks so that they can be executed in subsequent time windows, provided that the maximum allowed completion time is met; Set cross-node migration control parameters for the migration execution subtask to allow it to be executed in segments across multiple target compute nodes.
5. The intelligent computing power allocation method based on cloud-edge collaboration according to claim 1, characterized in that, In step S3, the steps of generating candidate execution time slice information for the corresponding subtask in different time windows include: Each candidate edge node receives the subtask requirement information for the corresponding subtask; Each candidate edge node generates candidate execution time slice information for each discrete time window based on its local computing power time slice sequence; Each candidate edge node generates time-connection control parameters based on the data transmission time information and state recovery time information between the computing node where the preceding subtask is located and the current candidate edge node. Based on the candidate execution time slice information and time connection parameters, a local negotiation result is formed and sent to the cloud node.
6. The intelligent computing power allocation method based on cloud-edge collaboration according to claim 1, characterized in that, In step S4, the step of generating the time-series execution chain of the subtask includes: The cloud node aggregates the local negotiation results returned by each candidate edge node; The time-series execution path of the subtask is generated based on the subtask execution time information, node reliability parameters, and node switching impact parameters. Under the conditions of satisfying the subtask completion time constraints, computing node computing power time slice capacity constraints, and dependency order constraints, determine the target computing node and target time window corresponding to each subtask; The determined result is output as the final allocation result.
7. The intelligent computing power allocation method based on cloud-edge collaboration according to claim 1, characterized in that, In step S5, the step of stitching together the execution states of multiple nodes based on state snapshots when a subtask is executed across computing nodes includes: A state snapshot is generated after the subtask completes its execution at the current target computation node. Send the state snapshot to the next target computing node; The next target computing node performs state recovery processing based on the state snapshot; Determine whether the continuous execution condition is met based on the state continuity parameter between the recovered state and the expected state; If the conditions for continuous execution are met, the subsequent subtasks will continue to be executed; otherwise, a state rollback or cloud node takeover will be triggered.
8. The intelligent computing power allocation method based on cloud-edge collaboration according to claim 1, characterized in that, In step S6, the step of pre-occupying computing power time slices within a future time window based on the computing power credit of the target computing node to form a borrowed computing power time slice includes: A computing power credit value is established for each computing node. The computing power credit value is generated based on the node's historical task completion stability, computing power time slice fulfillment consistency, and collaborative execution contribution. When the target computing node has insufficient computing power time slices within the current time window, it is determined whether the computing power credit value meets the borrowing conditions. When the borrowing conditions are met, the target computing node is allowed to pre-occupy a portion of the computing power time slice within a future time window to form a borrowed computing power time slice. The corresponding computing power time slices are reserved in the subsequent time window to complete the replenishment.
9. The intelligent computing power allocation method based on cloud-edge collaboration according to claim 1, characterized in that, In step S7, the steps of performing closed-loop correction on the computing power time slice sequence and subtask time sequence execution chain within the subsequent time window based on the execution feedback of each subtask include: Collect information on the actual execution time, computing time slice occupancy, and node switching of each subtask during the execution process; Based on the execution feedback, update the node reliability parameters and node state fluctuation parameters of each computing node in the subsequent time window; Regenerate the computing power time slice sequence for subsequent time windows based on the updated parameters; Regenerate the time-series execution chain of the subtasks and replace the original final assignment result.
10. A cloud-edge collaborative intelligent computing power allocation service system, characterized in that, The method for intelligent allocation of computing power based on cloud-edge collaboration, as described in any one of claims 1-9, comprises: The computing power time slice generation module is used to obtain the node status information of cloud nodes and multiple edge nodes in multiple discrete time windows in the future, and generate a computing power time slice sequence for each computing node based on the node status information. The task plasticity modeling module is used to acquire the task to be processed, perform task plasticity decomposition on the task to be processed to obtain multiple sub-tasks, and establish dependencies, execution time limits and migration constraints for each sub-task. The local negotiation module is used to send the computing power time slice sequence and sub-task requirement information to the candidate edge nodes for each sub-task, and each candidate edge node generates a local negotiation result for the corresponding sub-task based on the local available computing power time slice. The global clearing module receives the local negotiation results returned by each candidate edge node, combines the dependencies, execution time limits, migration constraints of each subtask, and computing power time slice sequences of each computing node to perform global clearing, determine the target computing node and target time window corresponding to each subtask, and generate the final allocation result. The execution control module is used to execute each subtask in the target computing node and target time window according to the final allocation result, and to perform multi-node execution state splicing when the subtask is executed across computing nodes. The credit borrowing module is used to borrow computing power credit based on the computing power credit of the target computing node when the current computing power time slice of the target computing node is insufficient to support the continued execution of the corresponding subtask during the execution process, and replenish it in the subsequent time window; The closed-loop correction module is used to perform closed-loop correction on the computing power time slice sequence, local negotiation results and final allocation results in subsequent time windows based on the execution feedback of each subtask.