Service placement and task unloading method based on tree genetic programming hyper-heuristic algorithm in cloud edge collaborative environment

Abstract

The invention relates to a service placement and task unloading method based on a tree genetic programming hyper-heuristic algorithm in a cloud-edge collaborative environment, and belongs to the technical field of task unloading of cloud computing and edge computing. According to the method, the service placement and task unloading strategy can be dynamically generated according to the resource configuration and the input task, so that the task processing reliability is improved, and the delay is reduced. The method comprises the following steps: firstly, designing a group of low-level heuristic algorithms according to the characteristics of a cloud edge collaborative environment and a task unloading target; then, the low-level heuristic algorithm is used as a gene to construct individual coding trees, and each tree represents a heuristic algorithm generated by a dynamic selection and combination low-level heuristic algorithm so as to initialize a population; secondly, iteratively evolving the population through selection, crossover and mutation operations, and reserving excellent individuals in the population evolution process by adopting an elitism strategy; finally, a heuristic algorithm with good performance in the aspects of reliability and delay optimization is generated and used for guiding service placement and task unloading.

Description

Technical Field

[0001] The present invention relates to a service placement and task offloading method based on a tree - shaped genetic programming hyper - heuristic algorithm in a cloud - edge collaborative environment, belonging to the technical field of task offloading in cloud computing and edge computing. Background Technique

[0002] With the development of the times, the Internet of Things (IoT), as an emerging technology, is gradually integrating into people's daily lives. Its core feature is to sense the surrounding environmental information through sensors, convert it into digital signals and transmit them to mobile devices for processing, and then the actuators perform corresponding operations according to the returned processing results. Typical IoT applications, such as smart wearable devices, intelligent monitoring, and smart healthcare, have been widely used. However, with the continuous growth of user demands and the diversification of IoT applications, the limited computing power of mobile devices is gradually unable to meet user needs. When facing large - scale data computing tasks, these tasks usually need to be offloaded to other computing resources for processing.

[0003] Cloud computing, as a computing model, can provide users with almost unlimited computing and storage resources, fully meeting users' computing needs. However, cloud computing usually requires users to upload local data to the cloud for processing, and then the cloud returns the calculation results. The transmission time overhead of this process is quite significant. Especially when the data volume is large, the transmission delay may reach an unacceptable level for users. In addition, the transmission of a large amount of data not only occupies bandwidth resources but may also cause network congestion, further increasing the delay. For delay - sensitive IoT applications, a high delay may lead to serious consequences. For example, in the intelligent driving scenario, an excessive delay may cause the vehicle to be unable to brake emergently when facing danger, resulting in traffic accidents. Therefore, although cloud computing can provide sufficient computing resources, it cannot meet the low - delay requirements of IoT applications.

[0004] Edge computing, as an emerging computing service model, by transmitting data to the edge for processing close to users, not only effectively solves the problem of insufficient computing power of mobile devices but also avoids excessive delay. Therefore, it can be well applied to IoT application scenarios. However, edge computing itself also has deficiencies: (1) Compared with cloud computing, the computing resources of edge computing are relatively limited and it is difficult to meet the computing needs of large - data - volume tasks. For example, more and more applications based on deep neural networks are deployed on mobile devices, and the computing resources of edge computing are difficult to meet the computing needs of such applications; (2) Edge computing transfers the original task load offloaded to the cloud to the edge. When the task load is too heavy, it may cause the edge to be overloaded, resulting in a decline in the task - processing performance of edge servers.

[0005] Facing the above problems, it is reasonable and necessary to combine the advantages of cloud computing and edge computing to construct a cloud-edge collaborative network architecture. For complex tasks with low latency sensitivity, they can be offloaded to the cloud for processing; while for simple tasks with high latency sensitivity, they can be offloaded to the edge for processing. During the task processing, the following two key issues need to be considered: (1) Service placement: In the cloud-edge collaborative environment, there are multiple computing resource nodes. How to select appropriate nodes to place application services to make full use of computing resources is an issue that needs to be considered; (2) Task offloading: The tasks submitted by users need to be sequentially passed to different services for execution during the processing. Only the computing resource nodes that have deployed the corresponding services can complete the task processing. Therefore, how to reasonably select offloading nodes to ensure the efficient processing of tasks is also an issue that needs to be focused on. In addition, the task processing in the cloud-edge collaborative environment also needs to pay attention to the reliability issue. Since the computing resource nodes in the cloud-edge collaborative environment are usually distributed in different geographical locations and these nodes communicate and cooperate through the backhaul network, there may be unreliable problems in network communication during data transmission. In addition, the edge servers may also fail during the task execution. These failures will all affect the processing of user requests, resulting in packet loss problems, increasing task processing latency, and further causing significant property losses. For example, the 4-hour outage of AWS in 2017 caused losses of $150 million to 54 out of the top 100 online retailers.

[0006] In recent years, task offloading, as the core issue in cloud-edge collaborative computing, has received extensive attention. This issue not only involves the offloading decision of tasks to computing resource nodes but also needs to jointly consider the deployment of application services to make full use of heterogeneous computing resources, reduce latency, and improve reliability. Since tasks can only be offloaded to nodes that have deployed the corresponding services, the task offloading and service placement problems are tightly coupled, forming a highly complex joint optimization problem, which has been proven to be NP-hard and difficult to obtain the optimal solution in polynomial time. For this reason, existing research has proposed various optimization methods, including heuristic algorithms, meta-heuristic algorithms, and decomposition strategies, around multiple optimization objectives such as latency, energy consumption, and service deployment cost, to improve the efficiency and quality of offloading decisions. However, most of the current research focuses on indicators such as latency, energy consumption, cost, and resource utilization, and few studies consider reliability as a key factor in task offloading. Therefore, there are still some problems that have not been fully solved in the task offloading problem in the cloud-edge collaborative environment. Summary of the Invention

[0007] The main purpose of the present invention is to provide a service placement and task offloading method based on tree-shaped genetic programming hyper-heuristic algorithm in a cloud-edge collaborative environment, aiming to solve the technical problem of high-reliability and low-latency offloading of tasks submitted by users in the cloud-edge collaborative environment.

[0008] To achieve the above object, the present invention proposes a tree-based genetic programming hyper-heuristic algorithm TBGP-HH, which can dynamically generate service placement and task offloading strategies according to resource allocation and input tasks to improve task processing reliability and reduce latency. First, a set of low-level heuristic algorithms are designed in combination with the task offloading objective. Then, they are used as genes to construct an individual coding tree to initialize the population. Next, the population is iteratively evolved through selection, crossover, and mutation operations, and an elitist retention strategy is adopted to retain excellent individuals. Finally, a heuristic algorithm with good performance in terms of reliability and latency optimization is generated to guide service placement and task offloading. The specific steps are as follows:

[0009] Step S1: Model the service placement and task offloading problem in the cloud-edge collaborative environment, including the cloud-edge collaborative network architecture model, application service and task model, service placement and task offloading model, and latency and reliability model.

[0010] Specifically:

[0011] Step S1.1: Cloud-edge collaborative network architecture model. As Figure 1 shown is the cloud-edge collaborative network architecture diagram, which includes three different types of computing resources: the remote cloud, the edge near the user, and the mobile devices within the edge service range. The cloud can provide almost unlimited computing and storage resources, but data transmission will bring relatively high network latency; the edge can provide relatively sufficient computing resources and can effectively reduce latency; mobile devices are limited by limited computing resources and battery life and can only handle relatively simple tasks. The cloud, the edge, and mobile devices can communicate with each other through the network and complete the tasks submitted by users through mutual cooperation. The set of computing resource nodes in the cloud-edge collaborative network architecture is represented by S = {s1, s2,..., s k ,..., s |S|}. For the computing resource node s k , it includes multiple attributes: resource type type(s k ), type(s k ) ∈ {0, 1, 2}, 0 represents the cloud, 1 represents the edge, 2 represents the mobile device; computing resource C(s k ); memory resource M(s k ); storage resource D(s k ); performance parameter λ e (s k ), which represents the average number of failures per unit time when s k executes a task. The smaller λ e (s k ), the more reliable s kThe better the execution performance; the communication quality parameter λ t (s k ), which represents s k When communicating with other nodes, the average number of communication failures per unit time, λ t (s k ) is smaller, indicating that s k has better communication conditions. The computing resource nodes in the cloud-edge collaborative network architecture communicate with each other through the network. For nodes s m and s n , the transmission bandwidth is BW(s m ,s n ).

[0012] Step S1.2: Application service and task model. An application consists of a series of service modules. There are data dependencies between service modules, and the output of one module may be the input of another module. The application is represented by App = {a1, a2,..., a i ,..., a |A|}, where a i represents the i-th module of the application App, and the computing resources required for the deployment of a i are c(a i ), the memory resources are m(a i ), and the storage resources are d(a i ). For the data dependencies between service modules, they are represented by E = {e i,j |1 ≤ i, j ≤ n, i ≠ j}. The tasks submitted by users will be sequentially transmitted to different service modules for execution during the processing, so the types of tasks will change continuously during the transmission. The set of task types is represented by T = {t1, t2,..., t i ,..., t |T|}, where t i represents the i-th type of task. For task t i , it can only be executed by a i . The computing load of t i is w(t i ), and the amount of data to be transmitted is data(t i ).

[0013] Step S1.3: Service placement and task offloading model.

[0014] For the i-th service module a i and the k-th computing resource node s k , their placement relationship is as follows:

[0015] C1:

[0016] If service module a i is placed on computing resource node s k , then x(a i , s k ) = 1; otherwise, x(a i , s k ) = 0. The set of service placement relationships is represented by .

[0017] Since an application module can be placed on multiple computing resource nodes, S i = {s k | a i ∈ App, x(a i , s k ) = 1} represents the set of computing resource nodes on which a i is placed. For the service placement problem, the following constraint conditions need to be satisfied: The computing resource, memory resource, and storage resource requirements of the service modules placed on a node cannot exceed the resource capacity provided by the node itself. That is:

[0018] C2:

[0019] C3:

[0020] C4:

[0021] For task t i , it can only be executed by the corresponding service module a i . As described above, the set of computing resource nodes on which a i is placed is represented by S i . Therefore, task t i can only be offloaded to and executed on the computing resource nodes in S i . The offloading relationship between the task and the computing resource nodes is as follows:

[0022] C5:

[0023] y(t i , s k ) = 1 indicates that task t i is offloaded to and executed on the computing resource node s i on which module a k is placed; otherwise, y(t i , s k ) = 0. The set of task offloading relationships is represented by . In addition, since task t i can only be offloaded to and executed on a certain computing resource node, so:

[0024] C6:

[0025] Step S1.4: Delay and reliability model.

[0026] The delay of a task consists of two parts: execution delay and transmission delay. For the execution delay, when task t i is offloaded to computing resource node s m for execution, the execution delay is:

[0027]

[0028] For the transmission delay, assume that after task t i completes execution on computing resource node s m and transforms into the next type t j , and t j needs to be executed on the computing resource node s j where a n is located. Then its transmission delay is:

[0029]

[0030] Therefore, the delay of task t i is as follows:

[0031] L(t i ) = ET(t i , s m ) + TT(t i , t j , s m , s n )

[0032] For the tasks submitted by users, the total delay is

[0033] The reliability of task processing consists of two parts: task execution reliability and task data transmission reliability. The task execution reliability is related to the performance of the computing resource node where the task is executed; the task data transmission reliability is related to the task data transmission volume data(t i ) and the communication status between computing resource nodes.

[0034] For the task execution reliability, assume that when task t i is executed on node s m , the number of fault occurrences is N(ET(t i , s m ). Then the probability of ξ fault occurrences during task execution is:

[0035]

[0036] If the task is executed reliably, it indicates that no failures have occurred during the task execution. Therefore, the task execution reliability is as follows:

[0037]

[0038] For the reliability of task data transmission, assume that during the task data transmission, the number of failure occurrences is N(TT(t i ,t j ,s m ,s n ))), then the probability of ξ failures occurring during the task data transmission is:

[0039]

[0040] Given that the link communication quality between two nodes depends on the party with poorer communication quality, therefore, λ t (s m ,s n ) = max(λ t (s m ), λ t (s n ))).

[0041] If the task data is transmitted reliably, it indicates that no failures have occurred during the task data transmission. Therefore, the task data transmission reliability is as follows:

[0042]

[0043] Therefore, the reliability of task t i processed on node s m is as follows:

[0044]

[0045] For the tasks submitted by users, the processing reliability is

[0046] Step S1.5: The problem of service placement and task offloading considering latency and reliability objectives in the cloud-edge collaborative environment can be expressed as: minimize L(T), maximize R(T), s.t. C1 - C6.

[0047] Step S2: Provide a detailed introduction to the proposed tree-based genetic programming hyper-heuristic algorithm TBGP-HH, including the algorithm framework and specific content. As Figure 2 shown is the framework diagram of the TBGP-HH algorithm, including population initialization, individual fitness evaluation, selection operation, crossover operation, and mutation operation.

[0048] Step S2.1: Population initialization is used to generate the initial population. To ensure that the initial population has sufficient diversity, including both individuals with large scale and complex structures and individuals with small scale and flexibility to promote a comprehensive search of the solution space, the ramped - half - and - half method is used to initialize individuals. Specifically, half of the individuals in the population are generated using the Full method, and their corresponding tree structures all reach the pre - set maximum depth; the other half of the individuals are generated using the Grow method, and their corresponding tree structures are randomly initialized within the depth range [d min , d max , making the overall structure more diverse. The encoding of individuals in the population is as Figure 3 shown. Among them, the first tree is used for resource selection in the service placement phase, and its leaf nodes are selected from terminals 1 - 7 in the terminal set shown in Table 1; the second tree is used for resource selection in the task offloading phase, and its leaf nodes are selected from terminals 8 - 11 in the terminal set shown in Table 1. The non - leaf nodes are all selected from the function set shown in Table 2 to associate different terminals. By constructing these two trees, a complete heuristic algorithm is formed.

[0049] Table 1 Terminal set

[0050]

[0051] Table 2 Function set

[0052]

[0053] Step S2.2: Individual fitness evaluation requires applying the resource selection rules represented by individuals to service placement and task offloading in the simulation environment, calculating the latency and reliability, and thus evaluating the fitness of individuals. In the service placement phase, the placement decision depends on the first resource selection rule R1. Specifically, first, it is necessary to determine whether the remaining resources of the resource node s k can meet the computing resource, memory resource, and storage resource requirements of the application service a i . If it is satisfied, the relevant attributes of s k are used as the input of R1 for calculation to determine its priority value R1(s k ). Since the application service can be placed on multiple resource nodes, when R1(s k ) is greater than the set threshold χ, the service a i can be placed on s k . In the task offloading phase, the task t i can only be offloaded to the resource node where the corresponding service a i is placed. Therefore, the second resource selection rule R2 is used to traverse the resource nodes where ai Resource node set S i , to determine the priority value R2(s of each node therein k ). Subsequently, select to unload task t i to the node with the highest priority value R2(s k ) for execution.

[0054] The fitness function is used to evaluate the quality of the generated heuristic algorithm individuals and plays a guiding and optimizing selection role in the population evolution process. During the task processing, if the task is complex, the delay will inevitably increase. However, this is usually within the user's expectation. In addition, the reliability of task processing will decrease as the number of task types increases. Although users can accept the increased delay caused by processing complex tasks, the execution failure of task requests is unacceptable. Therefore, as the number of task types increases, the weight of the reliability goal also needs to be increased accordingly. For this reason, the following fitness function is used to evaluate individuals:

[0055] Fit(I) = α(|T|)·R + (1 - α(|T|))·e -λL

[0056] This function comprehensively considers the reliability and delay goals, and dynamically adjusts the importance of reliability by introducing a dynamic weight coefficient α(|T|) before the reliability goal. Among them, λ is the penalty coefficient, and the larger the value of λ, the lower the tolerance for high delay. The larger the fitness value, the better the quality of the heuristic algorithm individual.

[0057] The calculation formula of α(|T|) is as follows:

[0058] α(|T|) = α0 + (1 - α0)·(1 - e -k(|T|-1 ))

[0059] When |T| is small, α(|T|) is close to the initial value α0; as |T| increases, α(|T|) gradually approaches 1, indicating that the importance of reliability is continuously increasing. Among them, k is the slope parameter, and the larger the value of k, the faster α(|T|) approaches 1.

[0060] Step S2.3: The selection operation is based on the fitness value of the individuals. By selecting excellent individuals from the current population for genetic operations, the quality of the generated offspring is ensured. The tournament selection method is used to select individuals.

[0061] Step S2.4: The crossover operation is used to enhance the diversity of the population. By selecting individuals from the population for mutual crossover, new offspring are obtained. First, select two individuals A and B from the population; then, perform the crossover operation on the two encoded trees of A and B respectively, thereby generating two new offspring individuals A' and B'. For the convenience of description, use A(R1), A(R2), B(R1), and B(R2) to represent the two encoded trees of individuals A and B respectively. The specific steps of the crossover operation are as follows: Randomly select a subtree from A(R1) and B(R1) respectively, and then exchange them. Similarly, perform a similar operation on A(R2) and B(R2), and finally generate offspring A' and B'. An example of the crossover operation is as Figure 4 shown.

[0062] Step S2.5: The mutation operation is used to enhance the diversity of individuals. By mutating individuals, new individuals are generated. First, randomly select a subtree from the encoded tree of the individual; then, replace the subtree with a random tree generated by the Grow method, thereby obtaining a new encoded tree. By performing a similar mutation operation on the two encoded trees in the individual, new offspring individuals are finally generated. An example of the mutation operation is as Figure 5 shown.

[0063] Step S2.6: Repeat steps S2.2 - S2.5 until the termination condition is met. Finally, the optimal individual in the population is the heuristic algorithm individual output by the TBGP - HH algorithm. Apply this algorithm to service placement and task offloading in real - world application scenarios to achieve the optimization goals of high reliability and low latency.

[0064] Compared with the prior art, the present invention has the following beneficial effects:

[0065] 1. The present invention generates a reasonable service placement and task offloading strategy through carefully designed terminals, thereby making more effective use of node resources and achieving optimal service placement and reasonable task offloading. As the number of users increases, the present invention will increase the importance of task - processing reliability, sacrificing part of the latency performance to improve the reliability of task processing. Therefore, in the case of a large number of users, the present invention can still reliably complete the processing of user tasks, showing strong adaptability.

[0066] 2. Under the condition of sufficient resource nodes, the present invention can perform more reasonable service placement and task offloading. By offloading tasks to nodes with sufficient resources for processing, the processing latency of tasks is effectively reduced, and the reliability of task processing is improved. BRIEF DESCRIPTION OF THE DRAWINGS

[0067] Figure 1 It is the cloud - edge collaborative network architecture diagram of the present invention.

[0068] Figure 2 This is the framework diagram of the TBGP-HH algorithm of the present invention.

[0069] Figure 3 This is an example diagram of the tree coding of the heuristic algorithm of the present invention.

[0070] Figure 4 This is an example diagram of the crossover operation of the present invention.

[0071] Figure 5 This is an example diagram of the mutation operation of the present invention.

[0072] Figure 6 This is the module diagram of the intelligent monitoring application program of the present invention.

[0073] Figure 7 This is an example of an individual of the heuristic algorithm in the scenario where the number of resource nodes of the present invention is 16.

[0074] Figure 8 This is the delay performance of the example of an individual of the heuristic algorithm of the present invention in a real application scenario.

[0075] Figure 9 This is the reliability performance of the example of an individual of the heuristic algorithm of the present invention in a real application scenario. Detailed implementation manners

[0076] The present invention will be described in detail below with reference to the accompanying drawings and specific embodiments. This embodiment is implemented on the premise of the technical solution of the present invention, and gives detailed implementation manners and specific operation processes, so that the advantages and features of the present invention can be more easily understood by those skilled in the art, thereby making a clearer and more definite definition of the protection scope of the present invention.

[0077] As Figure 6 shown is the module diagram of the intelligent monitoring application program in a real scenario. Intelligent monitoring integrates computer vision algorithms into cameras to achieve automated and intelligent analysis of the monitoring scenario, and it is widely used in fields such as smart cities and intelligent transportation. It mainly includes Motion detector, Object detector, Objecttracker and User interface modules, and its resource requirements are shown in Table 3.

[0078] Table 3 Resource requirements of the intelligent monitoring application program

[0079]

[0080] The placement of this application program service and the processing of offloading tasks specifically include the following steps:

[0081] Step S1: Initialize according to the cloud-edge collaborative environment resource configuration shown in Table 4. Taking the resource configuration setting of 16 resource nodes as an example, it includes 1 cloud, 5 edge nodes, and 10 mobile devices.

[0082] Table 4 Cloud-edge Collaborative Environment Resource Configuration

[0083]

[0084]

[0085] Step S2: Initialize the TBGP-HH algorithm parameters according to the characteristics of the cloud-edge collaborative environment and the task offloading goal. Taking the parameters shown in Table 5 as an example, it mainly includes parameters such as the population size ps, the minimum depth d of the tree min , the maximum depth d of the tree max , the crossover probability cr, the mutation probability mr, and the number of elite individuals μ, etc.

[0086] Table 5 TBGP-HH Experimental Parameter Settings

[0087]

[0088] Step S3: According to the set parameters, TBGP-HH first generates ps individuals. These individuals are initialized using the ramped-half-and-half method. Half of the individuals are generated using the Full method, and their corresponding tree structures all reach the pre-set maximum depth d max ; the other half of the individuals are generated using the Grow method, and their corresponding tree structures are randomly initialized within the depth range [d min , d max . Then, evaluate the fitness of the individuals. Take the relevant parameters of the heuristic algorithm individual I, the cloud-edge collaborative environment resource node set S, the application App, and the task type set T as the input of the simulation execution. Perform service placement and task offloading according to the resource selection rules R1 and R2, so as to calculate the delay and reliability of task processing, and then evaluate the fitness of the individuals. The specific process is as follows:

[0089]

[0090]

[0091] Step S4: Then, iteratively evolve the population through selection, crossover, and mutation operations, and adopt the elitist retention strategy to retain the μ excellent individuals with the largest fitness values during the population evolution process, so as to retain the structures of the excellent individuals. The specific process of the crossover operation is as follows:

[0092]

[0093] The specific process of the mutation operation is as follows:

[0094]

[0095] Step S5: Repeat the simulation execution process of step S3 and step S4 until the termination condition is met. Finally, obtain the optimal heuristic algorithm output by the algorithm, and apply this algorithm to service placement and task offloading in the real application scenario to achieve the optimization goal of high reliability and low latency. Figure 7 It is the optimal heuristic algorithm individual obtained under this embodiment. Use this individual for service placement and task offloading in the real application scenario, and the latency and reliability results are respectively as Figure 8 、 Figure 9 shown.

[0096] The specific implementation manners of the present invention have been described in detail in conjunction with the accompanying drawings. However, the present invention is not limited to the above implementation manners. Within the scope of knowledge possessed by those of ordinary skill in the art, various changes can be made without departing from the gist of the present invention.

Claims

1. A service placement and task offloading method based on a tree-shaped genetic programming hyper-heuristic algorithm in a cloud-edge collaborative environment, characterized in that According to resource allocation and input tasks, it is possible to dynamically generate service placement and task offloading strategies to improve task processing reliability and reduce latency.

2. The service placement and task offloading method based on the tree-shaped genetic programming hyper-heuristic algorithm in the cloud-edge collaborative environment according to claim 1, wherein The problem of service placement and task offloading that focuses on latency and reliability goals in the cloud-edge collaborative environment is mathematically expressed as: minimize L(T), maximize R(T), s.t. C1 - C6 where L(T) is the task processing latency, R(T) is the task processing reliability, and C1 - C6 are the constraint conditions.

3. The service placement and task offloading method based on the tree-shaped genetic programming hyper-heuristic algorithm in a cloud-edge collaborative environment according to claim 2, wherein, For the problem of service placement and task offloading that focuses on latency and reliability goals in the cloud-edge collaborative environment, the latency is mathematically expressed as: L(t i ) = ET(t i , s m ) + TT(t i , t j , s m , s n ) where ET(t i ,s m ) is the execution delay, TT(t i ,t j ,s m ,s n ) is the transmission delay, and L(t i ) is the processing delay of task t i .

4. A service placement and task offloading method based on a tree-shaped genetic programming hyper-heuristic algorithm in a cloud-edge collaborative environment according to claim 2, characterized in that For the problem of service placement and task offloading that focuses on latency and reliability goals in the cloud-edge collaborative environment, the reliability is mathematically expressed as: wherein, R exec (t i , s m ) is the execution reliability, R trans (t i , t j , s m , s n ) is the transmission reliability, R(t i , s m ) is the processing reliability of task t i .

5. The service placement and task offloading method based on the tree-shaped genetic programming hyper-heuristic algorithm in the cloud-edge collaborative environment according to claim 2, wherein The problem of service placement and task offloading that focuses on latency and reliability goals in the cloud-edge collaborative environment has the following constraints: Among them, C1 means that if service module a i is placed on computing resource node s k , then x(a i , s k ) = 1; otherwise, x(a i , s k ) = 0; C2 - C4 mean that the computing resource, memory resource, and storage resource requirements of the service modules placed on the node cannot exceed the resource capacity provided by the node itself; C5 means that y(t i , s k ) = 1 indicates that task t i is offloaded to the computing resource node s i where module a is placed k for execution; otherwise, y(t i , s k ) = 0; C6 means that task t i can only be offloaded to a certain computing resource node for execution.

6. The service placement and task offloading method based on the tree-shaped genetic programming hyper-heuristic algorithm in the cloud-edge collaborative environment according to claim 1, characterized in that The tree-based genetic programming hyper-heuristic algorithm TBGP-HH includes: Step S1: Initialize the parameters of the TBGP-HH algorithm and the resources in the cloud-edge collaborative environment; Step S2: Generate an initial population; Step S3: Evaluate the fitness values of the individuals in the population through the simulation execution process, and select the individuals using the tournament selection method; Step S4: Use the crossover operation to enhance the diversity of the population; Step S5: Use the mutation operation to enhance the diversity of the individuals; Step S6: Repeat Step S3 - Step S5 until the termination condition is met, and output the optimal individual in the population.

7. A service placement and task offloading method based on a tree-shaped genetic programming hyper-heuristic algorithm in a cloud-edge collaborative environment according to claim 6, characterized in that Initialize the population using the ramped - half - and - half method. Specifically, half of the individuals in the population are generated using the Full method, and the corresponding tree structures all reach the pre - set maximum depth; the other half of the individuals are generated using the Grow method, and the corresponding tree structures are randomly initialized within the depth range [d min , d max .

8. A service placement and task offloading method based on a tree-shaped genetic programming hyper-heuristic algorithm in a cloud-edge collaborative environment according to claim 6, characterized in that, The following fitness function is used to evaluate the individuals: Fit(I) = α(|T|)·R + (1 - α(|T|))·e -λL α(|T|) = α0 + (1 - α0)·(1 - e -k(|T|-1 )) where α(|T|) is the dynamic weight coefficient used to dynamically adjust the importance of reliability; λ is the penalty coefficient, and the larger the value of λ, the lower the tolerance for high latency.

9. A service placement and task offloading method based on a tree-shaped genetic programming hyper-heuristic algorithm in a cloud-edge collaborative environment according to claim 6, wherein The simulation execution process calculates the latency and reliability by applying the resource selection rules represented by the individuals to service placement and task offloading in the simulation environment, thereby evaluating the fitness values of the individuals: In the service placement phase, the placement decision depends on the first resource selection rule T1. First, it is necessary to determine whether the remaining resources of the resource node s k can meet the computing resource, memory resource, and storage resource requirements of the application service a i . If it is satisfied, the relevant attributes of s k are used as the input of R1 for calculation to determine its priority value R1(s k ). When R1(s k ) is greater than the set threshold χ, the service a i can be placed on s k . In the task offloading stage, use the second resource selection rule R2 to traverse the set of resource nodes S where a i is placed i , to determine the priority value R2(s k ) of each node therein, and select to offload the task t i to the node with the highest priority value R2(s k ) for execution.

10. A service placement and task offloading method based on a tree-shaped genetic programming hyper-heuristic algorithm in a cloud-edge collaborative environment according to claim 6, characterized in that The crossover operation is to perform crossover on the coding trees in the individuals: First, select two individuals A and B from the population; then, perform the crossover operation on the two coding trees of A and B respectively to generate two new offspring individuals A' and B'; for ease of description, use A(R1), A(R2), B(R1), and B(R2) to represent the two coding trees of individuals A and B respectively. The specific steps of the crossover operation are: randomly select a subtree from A(R1) and B(R1) respectively, and then exchange them; similarly, perform a similar operation on A(R2) and B(R2), and finally generate offspring A' and B'.

11. A service placement and task offloading method based on a tree-shaped genetic programming hyper-heuristic algorithm in a cloud-edge collaborative environment according to claim 6, characterized in that, The mutation operation is to perform mutation on the coding trees in the individuals: First, randomly select a subtree from the coding tree of the individual; then, replace the subtree with a random tree generated by the Grow method to obtain a new coding tree; by performing a similar mutation operation on the two coding trees in the individual, finally generate a new offspring individual.

Images