A Computing Offloading Method for High-Return Online Dependency-Aware Services Based on Graph Reconstruction

Abstract

The present invention relates to the design of a computing offloading method for online dependency-aware services with high returns based on graph reconstruction, belonging to the field of communication technologies. By using the directed graph of dependency-aware service requests for reconstruction, and in combination with time slots for edge cloud networks, computing resources and communication resources are allocated to effectively study the high returns of the system. The problem of computing offloading for dependency-aware services can be directly applied as long as it has a topological structure, there are dependencies between functions and they cannot be further split, and the system structure remains unchanged. First, the directed graph of dependency-aware services is reconstructed to achieve reasonable simplification. Then, resources are allocated for the computing requests and bandwidth requests of dependency-aware services, and further time slot resource allocation is carried out under the premise of meeting the delay requirements, so as to effectively achieve low-cost and high-return computing offloading. The present invention can distribute more services in the edge cloud and is also applicable to services with complex topological structures.

Description

Technical Field

[0001] The present invention belongs to the field of communication technologies and relates to a computing offloading method for high-yield online dependency-aware services based on graph reconstruction. Background Art

[0002] With the rapid development of the fifth-generation mobile communication (5G) technology, the number of services processed by user terminals is increasing. Limited by the limited computing power of terminal devices, it is difficult for terminal devices to handle a large number of computationally intensive services. Users can offload computationally intensive services to a remote cloud computing (CC) center for computing, thereby improving the computing speed. However, the central cloud is usually far from users, which will bring a large transmission delay, resulting in a low quality of service. With the development of the Internet of Things, the topological structures of new services are becoming increasingly complex. A service request can usually be decomposed into multiple subtasks with dependency relationships. It is becoming increasingly important to reasonably allocate resources for complex and variable dependency-aware services. Summary of the Invention

[0003] In view of this, the purpose of the present invention is to provide a computing offloading method for high-yield online dependency-aware services based on graph reconstruction.

[0004] To achieve the above purpose, the present invention provides the following technical solutions:

[0005] A computing offloading method for high-yield online dependency-aware services based on graph reconstruction, comprising the following steps:

[0006] S1: Layer the directed graph of the dependency-aware service arriving online in the edge cloud, remove the cross-layer edges of each directed graph, and then relayer to obtain a simplified graph;

[0007] S2: Reconstruct the service requests in the simplified graph;

[0008] S3: Obtain the underlying physical network devices where all subtasks in the graph are placed;

[0009] S4: Allocate time slot resources, computing resources, and bandwidth resources for all subtasks of the service request;

[0010] S5: After the online dependency-aware service allocation is completed, calculate the total revenue of the current online dependency-aware service request;

[0011] S6: Solve with the maximized revenue as the objective function.

[0012] Further, the layering of the directed graph of the dependency-aware service arriving online in the edge cloud in step S1 includes the following steps:

[0013] S11: For the directed graph of the dependency-aware service r arriving online at the edge cloud, assign layer 0 to all subtasks;

[0014] S12: Find the longest path in the graph, assign layers starting from the starting subtask as the first layer to obtain the total number of layers of the service request directed graph;

[0015] S13: Traverse the direct successor subtasks of the subtasks on the longest path in sequence to obtain a list of direct successor subtasks for each subtask on the path;

[0016] S14: Traverse the list of direct successor subtasks. If a direct successor subtask has only one direct predecessor subtask, increment the layer number by 1; if no layer-0 subtask is found, end the layer assignment; if all layer-0 subtasks are found, traverse all layer-0 subtasks, find the maximum layer number of all direct predecessor subtasks of this subtask, and the layer number of this layer-0 subtask is the maximum layer number of all direct predecessor subtasks plus 1, λ←max{λ pred(i)}+1.

[0017] Furthermore, the steps of removing the cross-layer edges of each directed graph and then reassigning layers described in step S1 include the following steps:

[0018] S15: Obtain the service request directed graph after layer assignment, and find multiple cross-layer connection edges existing in each service request directed graph;

[0019] S16: Arrange the destination nodes of the cross-layer edges in ascending order. When the layer numbers of the destination nodes of the cross-layer edges are the same, arrange the layer numbers where the source nodes of the cross-layer edges are located in ascending order, that is, find the cross-layer edge to be processed first;

[0020] S17: Store all the edges between the source node and the destination node of the cross-layer edge;

[0021] S18: Merge the two end nodes of all the edges described in step S17 in sequence. If the destination node of the merged edge is equal to the destination node of the cross-layer edge, find the order of merging that makes the layer number where the destination node of the cross-layer edge is located smaller after merging, store the layer number where the merged node is located, and the sum of the capacities of the merged nodes; if the destination node of the merged edge is not the destination node of the cross-layer edge, find the node that makes the layer number where the destination node of the cross-layer edge is located smaller after merging, store the layer number where the destination node of the cross-layer edge is located, and the sum of the capacities of the merged nodes;

[0022] S19: If there are multiple merging results, arrange them in ascending order and merge according to the result that reduces the layer number where the destination node of the cross-layer edge is located the most; if the reduction in the layer number where the destination node of the cross-layer edge is located is the same, merge in the way with the smallest sum of merged capacities;

[0023] S110: Perform steps S11 - S14 on the directed graph with the cross-layer edges removed to reassign layers and obtain a simplified graph.

[0024] Furthermore, step S2 specifically includes:

[0025] S21: Find the subtask i with the smallest computing resource request in the simplified graph ;

[0026] S22: Obtain the list of direct predecessor subtasks, the list of direct successor subtasks, and the list of subtasks at the same layer of subtask i;

[0027] S23: Sort the computing requests of the subtasks in the three lists obtained in step S22 above in ascending order;

[0028] S24: Perform a merging operation on subtask i and the smallest subtask j in step S23 above: If j is a direct predecessor subtask of i, merge i sequentially into j; if j is a direct successor subtask of i, merge i sequentially into j; if j is a subtask at the same layer as i, merge j in parallel into i; if the smallest computing requests in the list are the same, select the j subtask for sequential merging; if it exceeds the capacity threshold σ after merging, do not perform the merging operation.

[0029] Furthermore, step S3 specifically includes:

[0030] S31: Directly place the start subtask on the local node, recursively search all subtasks at the i-th layer, and obtain the set V of subtasks at the i-th layer 1 ; Traverse all subtasks at the i-th layer, find the subtasks at the (i + 1)-th layer, and obtain the set V of subtasks at the (i + 1)-th layer 2 , if it is an end subtask, select the local node;

[0031] S32: Find the set of underlying physical network devices where all subtasks at the (λ + 1)-th layer that have the same direct successor subtask as subtask j are located, V 3 ;

[0032] S33: Find the set of the top K underlying physical network devices with the shortest distance from the physical devices where all direct predecessor subtasks of subtask j are placed and the physical devices where the already placed subtasks are located, V 4 ;

[0033] S34: Calculate the remaining minimum CPU clock speed z' in all time slots 1 -z' K ;

[0034] S35: Calculate the shortest path p from the set of underlying physical devices where all direct predecessor subtasks of subtask j are located to each underlying physical network device in V 4 ; 1 -p K ;

[0035] S36: Calculate the shortest path p for all time slots 1 -p K of the minimum remaining bandwidth

[0036] S37: Select the underlying physical network device k with the minimum delay of subtask j as the underlying physical network device assigned to the current subtask j, i.e., Y[j] ← k.

[0037] Furthermore, step S4 specifically includes:

[0038] S41: Calculate the shortest path p in the graph according to the underlying physical network device Y[j] ← k assigned to the current subtask j e(i,j) ;

[0039] S42: Construct, optimize and solve the objective function to minimize the total cost of all dependent-aware service requests, and obtain the CPU clock speed assigned when each subtask is placed on the underlying physical network device and the bandwidth assigned when each edge is assigned to the physical link

[0040] S43: Sequentially allocate the start time slots of the directly subsequent subtasks according to the deadline time slot of each subtask and the sum of the transmission time slot numbers of the edges connecting the subtask and its directly subsequent subtasks.

[0041] Furthermore, the formula for calculating the total revenue of the current online dependent-aware service request in step S5 is:

[0042]

[0043] In the formula, R represents the set of service requests; G(N, L) represents the topological graph of the physical network; G r (V r , E r ) represents the service request network, the topological graph of the r-th service request; δ represents the unit price of computing resources in the edge cloud; β represents the unit price of bandwidth resources in the edge cloud; k represents the underlying physical network devices, including local devices and edge servers; l(k, k') represents the link between the underlying physical network devices k and k'; e(i, j) represents the edge between the adjacent subtasks i and j with a dependency relationship; represents the computing delay of the subtask i of the r-th service request assigned to the device k; represents the transmission delay of the edge e(i, j) of the r-th service request assigned to the underlying network link l(k, k'); z k represents the total computing resources of the device k; Denote the computing resources required for subtask i of the r-th service request; Denote the amount of data transmitted on edge e(i, j) of the r-th service request; T r Denote the deadline for each service request; B l(k,k') Denote the total bandwidth capacity of the physical link l(k, k') between devices k and k'; T denotes the decision time window, i.e., the total running time of the system; Denote the binary decision variable. If the i-th subtask of the r-th service request is placed on device k at time slot t, the value is 1, otherwise 0; Denote the binary decision variable. If the edge e(i, j) of the r-th service request is allocated to the physical link l(k, k') at time slot t, the value is 1, otherwise 0; Denote the non-negative integer variable, the start time slot of the i-th subtask of the r-th service request; Denote the non-negative integer variable, the CPU clock speed allocated to device k when the i-th subtask of the r-th service request is placed on device k at time slot t; Denote the non-negative integer variable, the bandwidth on the physical link l(k, k') when the edge e(i, j) of the r-th service request is allocated at time slot t; Denote the non-negative integer variable, the CPU clock speed allocated to device k when the i-th subtask of the r-th service request is placed on device k; Denote the non-negative integer variable, the bandwidth allocated to the physical link l(k, k') for the edge e(i, j) of the r-th service request; λ i Denote the layer where the subtask is located; λ pred(i) Denote the layer where the previous subtask of the subtask is located; σ denotes the capacity threshold; V 1 Denote the set of subtasks in the i-th layer; V 2 Denote the set of subtasks in the (i + 1)-th layer; V 3 Denote the underlying physical network devices where all subtasks in layer λ + 1 that have the same direct successor subtask as subtask j are located; V 4 Denote the set of the top K underlying physical network devices with the shortest distance from the physical devices where all direct predecessor subtasks of subtask j are placed and the physical devices where the already placed subtasks are located; z' k Denote the minimum remaining CPU clock speed of the underlying network device k in all time slots; p K Denote the K-th shortest path; Denote the minimum remaining bandwidth in all time slots of the K-th shortest path; Y[[j[] denotes the set of subtasks j offloaded to the underlying network device k; SG r Denote the topological graph of the service request obtained after the graph reconstruction step; Denote the minimum remaining CPU clock speed of subtask i placed in all time slots of underlying network device k; p e(i,j) Denote the shortest path.

[0044] Furthermore, the optimization model for minimizing the total cost of all dependency-aware service requests described in step S42 is:

[0045]

[0046] The constraints are as follows:

[0047]

[0048]

[0049]

[0050] Let Further optimize the optimization model to:

[0051]

[0052] The constraints are as follows:

[0053]

[0054]

[0055]

[0056] Furthermore, the objective function described in step S6 is:

[0057] Maximize benefit(r)

[0058] The constraints are:

[0059]

[0060]

[0061]

[0062]

[0063]

[0064]

[0065]

[0066]

[0067]

[0068] The beneficial effects of the present invention are as follows: By reconstructing the directed graph that depends on the perceived service requests, the present invention allocates computing resources and communication resources in combination with time slots for the edge cloud network, and conducts effective research on the high benefits of the system. It includes the problem of computing offloading for service requests that depend on perception. As long as the service has a topological structure, there are dependencies between its functions and it cannot be further split, it can be directly used without changing the system structure. First, reconstruct the directed graph of the service requests that depend on perception to achieve the purpose of reasonable simplification. Then, allocate resources for the computing requests and bandwidth requests of the service requests that depend on perception, and further allocate time slot resources while meeting the latency requirements, so as to effectively achieve low-cost and high-benefit computing offloading. Using the method for computing offloading of online service requests that depend on perception with high benefits based on graph reconstruction in the present invention can distribute more services in the edge cloud, and it is also applicable to services with complex topological structures. In addition, it can avoid a large amount of waste of system resources in the edge network, thereby improving the benefits of service providers and enhancing the effectiveness of the system.

[0069] The method design of the computing offloading of online service requests that depend on perception with high benefits based on graph reconstruction in the present invention is mainly oriented to scenarios such as service requests, service requests that depend on perception, and online service requests in the edge cloud network. The economic benefits of the present invention are mainly manifested in that by this method, time slot resources, computing resources, and communication resources are integrated to maximize the benefits of service providers and reduce costs as much as possible. Moreover, the method in the invention is conducive to increasing the amount of online service requests carried by the edge cloud, and thus is conducive to reducing the construction and operation costs of communication networks. More importantly, the present invention can be used in 5G new applications and edge clouds, and has obvious social benefits.

[0070] Other advantages, objectives, and features of the present invention will be described to some extent in the subsequent specification, and to some extent, will be obvious to those skilled in the art based on the study of the following text, or can be taught from the practice of the present invention. The objectives and other advantages of the present invention can be realized and obtained through the following specification. BRIEF DESCRIPTION OF THE DRAWINGS

[0071] In order to make the objectives, technical solutions, and advantages of the present invention clearer, the present invention will be described in detail preferably with reference to the accompanying drawings, where:

[0072] Figure 1 It is the structural diagram of the computing offloading of online service requests that depend on perception with high benefits based on graph reconstruction according to the embodiment of the present invention;

[0073] Figure 2It is a graph showing the change of the total revenue of the service provider based on the DATOwGR method with the increase of the dependency-aware service requests in the embodiments of the present invention;

[0074] Figure 3 It is a graph showing the change of the total cost of the service provider based on the DATOwGR method with the increase of the dependency-aware service requests in the embodiments of the present invention;

[0075] Figure 4 It is a graph showing the change of the dependency-aware service reception rate based on the DATOwGR method with the increase of the dependency-aware service requests in the embodiments of the present invention;

[0076] Figure 5 It is a graph showing the change of the total revenue of the service provider based on the DATOwGR method with the increase of the edge server capacity threshold in the embodiments of the present invention;

[0077] Figure 6 It is a graph showing the change of the total cost of the service provider based on the DATOwGR method with the increase of the edge server capacity threshold in the embodiments of the present invention;

[0078] Figure 7 It is a graph showing the change of the dependency-aware service reception rate based on the DATOwGR method with the increase of the edge server capacity threshold in the embodiments of the present invention;

[0079] Figure 8 It is a graph showing the change of the total revenue of the service provider based on the DATOwGR method with the increase of the arrival rate in the embodiments of the present invention;

[0080] Figure 9 It is a graph showing the change of the total cost of the service provider based on the DATOwGR method with the increase of the arrival rate in the embodiments of the present invention;

[0081] Figure 10 It is a graph showing the change of the reception rate of the dependency-aware service requests based on the DATOwGR method with the increase of the arrival rate in the embodiments of the present invention. Detailed implementation manners

[0082] The following illustrates the implementation manners of the present invention through specific specific examples. Those skilled in the art can easily understand other advantages and effects of the present invention from the content disclosed in this specification. The present invention can also be implemented or applied through other different specific implementation manners. The details in this specification can also be modified or changed based on different viewpoints and applications without departing from the spirit of the present invention. It should be noted that the diagrams provided in the following embodiments only illustrate the basic concept of the present invention schematically. Without conflict, the following embodiments and the features in the embodiments can be combined with each other.

[0083] Among them, the attached drawings are only for illustrative purposes, showing only schematic diagrams rather than actual physical diagrams, and should not be construed as limiting the present invention; in order to better illustrate the embodiments of the present invention, some components in the attached drawings will be omitted, enlarged or reduced, which do not represent the dimensions of the actual product; for those skilled in the art, it is understandable that some well-known structures and their descriptions in the attached drawings may be omitted.

[0084] In the attached drawings of the embodiments of the present invention, the same or similar reference numerals correspond to the same or similar components; in the description of the present invention, it should be understood that if there are terms such as "upper", "lower", "left", "right", "front", "rear", etc. indicating the orientation or positional relationship, they are based on the orientation or positional relationship shown in the attached drawings. This is only for the convenience of describing the present invention and simplifying the description, rather than indicating or implying that the device or element referred to must have a specific orientation, be constructed and operated in a specific orientation. Therefore, the terms describing the positional relationship in the attached drawings are only for illustrative purposes and should not be construed as limiting the present invention. For those of ordinary skill in the art, the specific meanings of the above terms can be understood according to specific circumstances.

[0085] The present invention provides a computing offloading system for online dependency-aware services based on an edge network, as Figure 1 shown, the main parts: Central Cloud (Cloud), Edge Cloud, Edge Server, Base Station, User, Dependency-aware Task Requests.

[0086] In this embodiment, the online dependency-aware service request, as Figure 1 shown, can be offloaded to the edge cloud. A computing offloading method that performs graph reconstruction on the directed graph of the online dependency-aware service and effectively allocates time slot resources, computing resources, and communication resources to maximize the total revenue of the service provider. The high-revenue computing offloading method for online dependency-aware services (Dependency-Aware Task Offloading with Graph Reconstruction, DATOwGR) is described as follows:

[0087] Step 1: For the directed graph of the dependency-aware service r that arrives at the edge cloud online, assign layer 0 to all subtasks;

[0088] Step 2: Find the longest path in the graph, and assign layers starting from the starting subtask as the first layer to obtain the total number of layers of the service request directed graph;

[0089] Step 3: Traverse the direct successor subtasks of the subtasks on the longest path in sequence to obtain the list of direct successor subtasks of each subtask on the path;

[0090] Step 4: Traverse the list of direct successor subtasks. If a direct successor subtask has only one direct predecessor subtask, increment the layer number by 1; if no layer-0 subtask is found, end the layer assignment; if all layer-0 subtasks are found, traverse all layer-0 subtasks, find the maximum layer number among all the direct predecessor subtasks of this subtask, and the layer number of this layer-0 subtask is the maximum layer number of all its direct predecessor subtasks plus 1, λ ← max{λ pred(i)}+1;

[0091] Step 5: Based on the business request directed graph after layer assignment obtained in Steps 1 - 4, find multiple connecting edges that span layers (i.e., the layer difference is greater than or equal to 2) in each business request directed graph;

[0092] Step 6: Sort the destination nodes of the cross-layer edges in ascending order. When the layer numbers of the destination nodes of the cross-layer edges are the same, sort the layer numbers where the source nodes of the cross-layer edges are located in ascending order, that is, find the cross-layer edges to be processed first;

[0093] Step 7: Store all the edges between the source nodes and destination nodes of the cross-layer edges;

[0094] Step 8: Successively merge the two end nodes of all the edges in Step 7. If the destination node of the merged edge is equal to the destination node of the cross-layer edge, find the order of merging that makes the layer number of the destination node of the cross-layer edge smaller after merging, and store the layer number where the merged node (the source node of the edge) is located, the sum of the capacities of the merged nodes; if the destination node of the merged edge is not the destination node of the cross-layer edge, find the node that makes the layer number of the destination node of the cross-layer edge smaller after merging, store the layer number where the destination node of the cross-layer edge is located, and the sum of the capacities of the merged nodes;

[0095] Step 9: If there are multiple merging results, sort them in ascending order and merge according to the result that reduces the layer number of the destination node of the cross-layer edge the most; if the reduction in the layer number of the destination node of the cross-layer edge is the same, merge in the way with the smallest sum of merged capacities;

[0096] Step 10: Invoke Steps 5 - 9 above to remove all cross-layer edges;

[0097] Step 11: Perform Steps 1 - 4 above on the directed graph after removing the cross-layer edges to reassign layers;

[0098] Step 12: Based on the simplified graph obtained in Steps 1 - 11 above, find the subtask i with the smallest computing resource request in the graph in the graph;

[0099] Step 13: Obtain the list of direct predecessor subtasks, the list of direct successor subtasks, and the list of subtasks at the same layer of subtask i;

[0100] Step 14: Arrange the calculation requests of the subtasks in the three lists obtained in the previous step 13 in ascending order;

[0101] Step 15: Perform a merging operation on subtask i and the smallest subtask j in the previous step 14. If j is the direct predecessor subtask of i, merge i into j sequentially; if j is the direct successor subtask of i, merge i into j sequentially; if j is a subtask at the same level as i, merge j into i in parallel. If the smallest calculation requests in the list are the same, select the j subtask for sequential merging. If the capacity threshold σ is exceeded after merging, no merging operation is performed;

[0102] Step 16: Obtain the final simplified graph after reconstructing the service request graph according to the previous steps 1 - 15;

[0103] Step 17: Start directly placing the subtasks on the local nodes, recursively search all the subtasks at the i-th layer, and obtain the set of subtasks V at the i-th layer 1 ; Traverse all the subtasks at the i-th layer, find the subtasks at the (i + 1)-th layer, and obtain the set of subtasks V at the (i + 1)-th layer 2 , if it is an end subtask, select the local node;

[0104] Step 18: Find the set of underlying physical network devices, where all the underlying physical network devices V where the subtasks in the (λ + 1)-th layer that have the same direct successor subtask as subtask j are located 3 ;

[0105] Step 19: Find the set of the top K underlying physical network devices V with the shortest distance from the physical devices where all the direct predecessor subtasks of subtask j are placed and the physical devices where the already placed subtasks are located 4 ;

[0106] Step 20: Calculate the remaining minimum CPU clock speed z' in all time slots 1 —z' K ;

[0107] Step 21: Calculate the shortest path p from the set of underlying physical devices where all the direct predecessor subtasks of subtask j are located to each underlying physical network device in V 4 —p 1 —p K ;

[0108] Step 22: Calculate the minimum remaining bandwidth of the shortest path p in all time slots 1 -p K ;

[0109] Step 23: Utilize z' obtained from the previous steps 18 - 21 1 —z' K and Calculate the total delay;

[0110] Step 24: Select the underlying physical network device k with the minimum delay of subtask j as the underlying physical network device assigned to the current subtask j, i.e., Y[j] ← k;

[0111] Step 25: Invoke the aforementioned Steps 18 - 24 to obtain the underlying physical network devices where all subtasks in the graph are placed;

[0112] Step 26: Calculate the shortest path p in the graph according to the aforementioned Step 24 e(i,j) ;

[0113] Step 27: Solve according to the optimization model P3 to obtain the CPU clock speed assigned when each subtask is placed on the underlying physical network device and the bandwidth assigned when each edge is assigned to the physical link

[0114] Step 28: Sequentially allocate the start time slot of the directly subsequent subtask according to the deadline time slot of each subtask and the sum of the transmission time slot numbers of the edge connecting the subtask and the directly subsequent subtask.

[0115] Step 29: Complete the allocation of time slot resources, computing resources, and bandwidth resources for all subtasks of the service request according to the aforementioned Steps 26 - 28, i.e., and

[0116] Step 30: If the online dependency-aware service is completed with allocation at this time, the total revenue calculation formula for the current online dependency-aware service request is:

[0117]

[0118] The meanings of the variables appearing in this embodiment are as follows:

[0119] · R: Represents the set of service requests;

[0120] · G(N, L): Represents the topology graph of the physical network;

[0121] · G r (V r , E r ): Represents the service request network, the topology graph of the rth service request;

[0122] · δ: Represents the unit price of computing resources in the edge cloud;

[0123] · β: Represents the unit price of bandwidth resources in the edge cloud;

[0124] · k: Represents the underlying physical network devices, including local devices and edge servers;

[0125] · l(k, k'): Represents the link between the underlying physical network devices k and k';

[0126] · e(i, j): Represents the edge between adjacent subtasks i and j with a dependency relationship;

[0127] · Represents the computing delay when the subtask i of the r-th service request is assigned to device k;

[0128] · Represents the transmission delay when the edge e(i, j) of the r-th service request is assigned to the underlying network link l(k, k');

[0129] · z k : Represents the total computing resources of device k;

[0130] · Represents the computing resources required by the subtask i of the r-th service request;

[0131] · Represents the amount of data transmitted on the edge e(i, j) of the r-th service request;

[0132] · T r : Represents the deadline of each service request;

[0133] · B l(k,k') : Represents the total bandwidth capacity of the physical link l(k, k') between devices k and k';

[0134] · T: Represents the decision time window, i.e., the total running time of the system;

[0135] · Represents a binary decision variable. The value is 1 if the i-th subtask of the r-th service request is placed on device k at time slot t, otherwise 0;

[0136] · Represents a binary decision variable. The value is 1 if the edge e(i, j) of the r-th service request is assigned to the physical link l(k, k') at time slot t, otherwise 0;

[0137] · Represents a non-negative integer variable, which is the start time slot of the i-th subtask of the r-th service request;

[0138] · Represents a non-negative integer variable, which is the CPU clock speed assigned to device k when the i-th subtask of the r-th service request is placed on device k at time slot t;

[0139] · Denote a non - negative integer variable, which is the bandwidth of the edge e(i, j) of the r - th service request allocated to the physical link l(k, k') at the t - th time slot;

[0140] · Denote a non - negative integer variable, which is the CPU clock speed allocated to device k when the i - th sub - task of the r - th service request is placed on device k;

[0141] · Denote a non - negative integer variable, which is the bandwidth of the edge e(i, j) of the r - th service request allocated to the physical link l(k, k');

[0142] ·λ i : The layer where the sub - task is located;

[0143] ·λ pred(i) : The layer where the previous sub - task of the sub - task is located;

[0144] ·σ: Capacity threshold;

[0145] ·V 1 : The set of sub - tasks in the i - th layer;

[0146] ·V 2 : The set of sub - tasks in the (i + 1) - th layer;

[0147] ·V 3 : The underlying physical network devices where all sub - tasks in the (λ + 1) - th layer with the same direct successor sub - task as sub - task j are located;

[0148] ·V 4 : The set of the top K underlying physical network devices with the shortest distance from the physical devices where all direct - predecessor sub - tasks of sub - task j are placed and the physical devices where the already - placed sub - tasks are located;

[0149] ·z' k : The minimum remaining CPU clock speed of the underlying network device k in all time slots;

[0150] ·p K : The K - th shortest path;

[0151] · The minimum remaining bandwidth of the K - th shortest path in all time slots;

[0152] ·Y[j]: The set of sub - tasks j offloaded to the underlying network device k;

[0153] ·SG r : The topological graph of the service request obtained after the graph reconstruction step;

[0154] · Subtask i is placed at the minimum remaining CPU clock speed in all time slots of the underlying network device k;

[0155] ·p e(i,j) : The shortest path;

[0156] The objective function of this embodiment is to maximize the benefit, as shown in formula (2):

[0157] Maximize benefit(r) (2)

[0158] The constraints are as follows:

[0159]

[0160]

[0161]

[0162]

[0163]

[0164]

[0165]

[0166] The objective function in Equation (2) aims to maximize the benefits of all dependency-aware service requests, including the request computing cost and request bandwidth cost of dependency-aware service requests, the computing cost of node allocation for offloading dependency-aware service requests to edge nodes, and the bandwidth cost of link allocation. Equations (3) and (4) are the constraints for offloading dependency-aware services to edge nodes. Equation (3) indicates that each subtask in the dependency-aware request should be assigned to an edge node in the physical network. Equation (4) shows that the resources occupied by all subtasks offloaded to the edge node in any time slot t should not exceed the computing resources of the edge node. Equations (5) - (7) are the link constraints in the dependency-aware service. Equation (5) means that multiple physical links cannot be selected simultaneously for each edge in the dependency-aware request. Equation (6) means that in T, each edge in the dependency-aware request is assigned to an acyclic physical path between edge clouds to relieve the burden on its terminal functions, and traffic conservation is specified in Equation (6). Equation (7) means that the bandwidth occupied by the service request on each physical link should not exceed the total bandwidth capacity of the link. Equations (8) and (9) are the dependency constraints of the dependency-aware request. Equation (8) means that for the link relationship between any subtasks of each service request, the start time slot of subtask j related to the dependency of subtask i must be greater than the completion time slot of subtask i. Equation (9) means that for each service request, the end subtask is completed on the local device, and the difference between its completion time slot and the start time slot of the start subtask is not greater than the deadline of each service request, that is, the latency constraint of the dependency-aware service request.

[0167] In this embodiment (2 - 27), the optimization model P3 is a transformed form of P2, and P2 is to minimize the cost, as shown in formula (10):

[0168]

[0169] The constraint conditions are as follows:

[0170]

[0171]

[0172]

[0173] Let The optimization model P2 is converted to P3:

[0174]

[0175] The constraint conditions are as follows:

[0176]

[0177]

[0178]

[0179] The objective function in Equation (10) indicates minimizing the total cost of all dependent-aware service requests. As can be seen from Equation (11), after allocating computing resources and bandwidth resources to subtasks and connection edges, the service request completion delay cannot be greater than the deadline of each task request. Equations (12) and (13) indicate that the computing resources and bandwidth resources allocated to subtasks and connection edges cannot exceed the current remaining capacity. Equations (14)-(17) are the transformed forms of Equations (10)-(13).

[0180] The edge cloud network of this embodiment is an improvement of n11s26 based on a large-scale network topology, which includes 11 edge servers and 11 local devices respectively, that is, N s = 11 and N u = 11; it should be noted that this setting is only for illustrating this embodiment, and in actual use, the physical network may have different network topologies. The parameters adopted in this embodiment are as follows: each edge node has a computing resource of 96 CPUs, each local device has a computing resource of 50 CPUs, and the total bandwidth of each link is 100 Mbps. The number of subtasks of the dependent-aware service request is randomly generated in [6, 8], and the edges connecting the subtasks are generated in [5, 17]. The resource amount of each subtask request of each dependent-aware service is randomly generated between [1, 6] CPUs, the resource amount of each bandwidth request is randomly generated between [1, 6] Mbps, and the data volume transmitted by each edge is randomly generated between [1, 8] Mbits. In addition, each service request is randomly generated by the local device, the number of online arriving service requests is randomly generated in [10, 100], and the arrival rate of the service request is set to [0.5, 4].

[0181] The comparison methods (Baselines) involved in this embodiment are Dependency-Aware Task Offloading without Graph Reconstruction (DATOoGR), Bipartite Task Offloading with Graph Reconstruction (BTOwGR), and Bipartite Task Offloading without Graph Reconstruction (BTOoGR). The difference from the DATOwGR method is that the DATOoGR method does not perform graph reconstruction after the arrival of dependency-aware task requests. The BTOwGR method uses the bipartite graph method when offloading dependency-aware task requests. The BTOoGR method does not perform graph reconstruction after the arrival of dependency-aware task requests and uses the bipartite graph method when offloading.

[0182] Perform performance analysis on the system proposed in this embodiment. By Figure 2 — Figure 4 Observe the changes in the total revenue of the service provider, the total cost, and the number of dependency-aware task requests carried by the edge cloud of the DATOwGR method of the system when the number of subtasks is fixed at 8, the task request arrival rate is 0.5, and the capacity threshold is 20. As the number of dependency-aware task requests gradually increases from 10 to 100, for the DATOwGR method in the instance, the total revenue is higher than that of the comparison algorithms, the total cost is lower than that of the comparison algorithms, and the number of dependency-aware task requests carried by the edge cloud is higher than that of the comparison algorithms. By Figure 5 — Figure 7 It can be known that when the number of task requests is 100, the number of subtasks per task request is fixed at 8, the task request arrival rate is 0.5, and the capacity threshold increases from 5 to 50, observe the changes in the total revenue of the service provider, the total cost, and the number of dependency-aware task requests carried by the edge cloud. Since DATOoGR and BTOoGR do not involve the merging operation of subtasks, different merging capacity thresholds have no effect on them. For the selection of the merging capacity threshold in the instance, it can be flexibly selected according to the requirements in different scenarios. The total revenue obtained by the system through the DATOwGR method is higher than that of the comparison algorithms, the total cost is lower than that of the comparison algorithms, and the number of dependency-aware task requests carried by the edge cloud is higher than that of the comparison algorithms. By observing Figure 8 — Figure 10, when the number of business requests is 100, the number of subtasks for each business request is fixed at 8, and the capacity threshold is 20, as the arrival rate of dependency-aware business requests increases from 0.5 to 4, the changes in the total revenue of the service provider, the total cost, and the dependency-aware business requests carried by the edge cloud. The system still has advantages in these three aspects through the DATOwGR method, and the proposed DATOwGR algorithm has good elasticity and scalability, and can handle different task request scenarios.

[0183] Finally, it should be noted that the above embodiments are only used to illustrate the technical solutions of the present invention and not to limit them. Although the present invention has been described in detail with reference to the preferred embodiments, those of ordinary skill in the art should understand that the technical solutions of the present invention can be modified or equivalently replaced without departing from the spirit and scope of the present technical solution, and they should all be covered within the scope of the claims of the present invention.

Claims

1. A computational offloading method for high-revenue online dependency-aware services based on graph reconstruction, characterized in that: It includes the following steps: S1: Layer the directed graph of the dependency-aware service arriving online in the edge cloud, remove the cross-layer edges of each directed graph, and then relayer to obtain a simplified graph; The layering of the directed graph of the dependency-aware service arriving online in the edge cloud includes the following steps: S11: For the directed graph of the dependency-aware service r arriving online in the edge cloud, all subtasks are assigned layer 0; S12: Find the longest path in the graph, and layer starting from the start subtask as the first layer to obtain the total number of layers of the service request directed graph; S13: Traverse the direct successor subtasks of the subtasks on the longest path in sequence to obtain a list of the direct successor subtasks of each subtask on the path; S14: Traverse the list of direct successor subtasks. If a direct successor subtask has only one direct predecessor subtask, increment the layer number by 1. If no layer-0 subtasks are found, end the layer assignment. If all layer-0 subtasks are found, traverse all layer-0 subtasks, find the maximum layer of all direct predecessor subtasks of this subtask, and the layer number of this layer-0 subtask is the maximum layer number of all direct predecessor subtasks plus 1, λ ← max{λ pred(i)}+1; The removing of the cross-layer edges of each directed graph and then relayering includes the following steps: S15: Obtain the layering service request directed graph, and find multiple connecting edges that cross layers in each service request directed graph; S16: Arrange the destination nodes of the cross-layer edges in ascending order. When the layers of the destination nodes of the cross-layer edges are the same, arrange the layers where the source nodes of the cross-layer edges are located in ascending order, that is, find the cross-layer edges to be processed first; S17: Store all the edges between the source node and the destination node of the cross-layer edge; S18: Merge the two end nodes of all the edges in step S17 in sequence. If the destination node of the merged edge is equal to the destination node of the cross-layer edge, find the order of merging that makes the layer where the destination node of the cross-layer edge is located smaller after merging, store the layer where the merged node is located, and the sum of the capacities of the merged nodes; If the destination node of the merged edge is not the destination node of the cross-layer edge, find the node that will make the layer where the destination node of the cross-layer edge is located smaller after merging, store the layer where the destination node of the cross-layer edge is located, and the sum of the capacities of the merged nodes; S19: If there are multiple merging results, arrange them in ascending order and merge according to the result that reduces the layer where the destination node of the cross-layer edge is located the most; If the reduction in the layer where the destination node of the cross-layer edge is located is the same, merge in the way with the smallest sum of merged capacities; S110: Perform steps S11 - S14 on the directed graph after removing the cross-layer edges and relayer to obtain a simplified graph; S2: Reconstruct the service requests in the simplified graph; S3: Obtain the underlying physical network devices where all subtasks in the graph are placed; S4: Allocate slot resources, computing resources, and bandwidth resources for all subtasks of the service request; S5: After the online dependency-aware service allocation is completed, calculate the total revenue of the current online dependency-aware service request; S6: Solve with the maximization of revenue as the objective function.

2. The computational offloading method for high-revenue online dependency-aware services based on graph reconstruction according to claim 1, characterized in that: Step S2 specifically includes: S21: Find the subtask i with the smallest computing resource request in the simplified graph with the smallest computing resource request S22: Obtain the list of direct preorder subtasks, the list of direct successor subtasks, and the list of subtasks in the same layer of subtask i; S23: Arrange the computing requests of the subtasks in the three lists obtained in the previous step S22 in ascending order; S24: Merge subtask i with the smallest subtask j in the aforementioned step S23: If j is the direct predecessor subtask of i, merge i sequentially into j; if j is the direct successor subtask of i, merge i sequentially into j; if j is a sibling subtask of i, merge j in parallel into i; if the smallest computing requests in the list are the same, select the j subtask for sequential merging; if the capacity threshold σ is exceeded after merging, no merging operation is performed.

3. The computing offloading method for high-yield online dependency-aware services based on graph reconstruction according to claim 2, characterized in that: Step S3 specifically includes: S31: The start subtask is directly placed on the local node, recursively search all subtasks at the i-th layer to obtain the subtask set V at the i-th layer 1 ; Traverse all subtasks at the i-th layer, find the subtasks at the (i + 1)-th layer to obtain the subtask set V at the (i + 1)-th layer 2 , if it is an end subtask, select the local node; S32: Find the set of underlying physical network devices, where V is the underlying physical network devices where all the subtasks in layer λ + 1 that have the same direct successor subtask as subtask j are located 3 ; S33: Find the set V of the top K underlying physical network devices with the shortest distances to the physical devices where all the direct predecessor subtasks of subtask j are placed and the physical devices where the placed subtasks are located 4 ; S34: Calculate the remaining minimum CPU clock speed z' among all time slots 1 -z' K ; S35: Calculate the shortest path p from the set of underlying physical devices where all direct predecessor subtasks of subtask j are located to each underlying physical network device in V 4 ; 1 -p K ; S36: Calculate the shortest path p for all time slots 1 -p K of the minimum remaining bandwidth S37: Select the underlying physical network device k with the smallest delay of subtask j as the underlying physical network device allocated to the current subtask j, that is, Y[j] ← k.

4. The computing offloading method for high-yield online dependency-aware services based on graph reconstruction according to claim 3, characterized in that: Step S4 specifically includes: S41: Calculate the shortest path p in the graph based on the underlying physical network device Y[j]←k assigned to the current subtask j e(i,j) ; S42: Construct, optimize, and solve an objective function that minimizes the total cost of all dependency-aware service requests, and obtain the CPU clock speed assigned to each subtask when it is placed on the underlying physical network device and the bandwidth assigned to each edge when it is assigned to a physical link S43: Sequentially allocate the start time slot of the direct successor subtask according to the deadline time slot of each subtask and the sum of the transmission time slot numbers of the edge connecting the subtask and its direct successor subtask.

5. The computing offloading method for high-yield online dependency-aware services based on graph reconstruction according to claim 4, characterized in that: The total benefit calculation formula for the current online dependency-aware service request in step S5 is: where \(R\) represents the set of service requests; \(G(N,L)\) represents the topological graph of the physical network; \(G\) r (V r ,E r ) represents the service request network, the topological graph of the \(r\)-th service request; \(\delta\) represents the unit price of computing resources in the edge cloud; \(\beta\) represents the unit price of bandwidth resources in the edge cloud; \(k\) represents the underlying physical network devices, including local devices and edge servers; \(l(k,k')\) represents the link between the underlying physical network devices \(k\) and \(k'\); \(e(i,j)\) represents the edge between adjacent subtasks \(i\) and \(j\) with a dependency relationship; represents the computing delay when the \(i\)-th subtask of the \(r\)-th service request is assigned to device \(k\); represents the transmission delay when the edge \(e(i,j)\) of the \(r\)-th service request is assigned to the underlying network link \(l(k,k')\); \(z\) k represents the total computing resources of device \(k\); represents the computing resources required for the \(i\)-th subtask of the \(r\)-th service request; represents the amount of data transmitted on the edge \(e(i,j)\) of the \(r\)-th service request; \(T\) r represents the deadline for each service request; \(B\) l(k,k') represents the total bandwidth capacity of the physical link \(l(k,k')\) between devices \(k\) and \(k'\); \(T\) represents the decision time window, that is, the total running time of the system; represents the binary decision variable, the \(i\)-th subtask of the \(r\)-th service request is placed on device \(k\) at time slot \(t\), with a value of 1 if so, otherwise 0; represents the binary decision variable, the edge \(e(i,j)\) of the \(r\)-th service request is assigned to the physical link \(l(k,k')\) at time slot \(t\), with a value of 1 if so, otherwise 0; represents the non - negative integer variable, the start time slot of the \(i\)-th subtask of the \(r\)-th service request; represents the non - negative integer variable, the CPU clock speed allocated by device \(k\) when the \(i\)-th subtask of the \(r\)-th service request is placed on device \(k\) at time slot \(t\); represents the non - negative integer variable, the bandwidth allocated to the physical link \(l(k,k')\) when the edge \(e(i,j)\) of the \(r\)-th service request is assigned to it at time slot \(t\); represents the non - negative integer variable, the CPU clock speed allocated by device \(k\) when the \(i\)-th subtask of the \(r\)-th service request is placed on device \(k\); represents the non - negative integer variable, the bandwidth allocated to the physical link \(l(k,k')\) when the edge \(e(i,j)\) of the \(r\)-th service request is assigned to it; \(\lambda\) i represents the layer where the subtask is located; \(\lambda\) pred(i) Denotes the layer where the predecessor subtask of the subtask is located; σ denotes the capacity threshold; V 1 Denotes the set of subtasks in the i-th layer; V 2 Denotes the set of subtasks in the (i + 1)-th layer; V 3 Denotes the underlying physical network devices at the bottom layer where all subtasks in the (λ + 1)-th layer having the same direct successor subtask as subtask j are located; V 4 Denotes the set of the top K underlying physical network devices with the shortest distance from the physical devices where all direct predecessor subtasks of subtask j are placed and the physical devices where the placed subtasks are located; z' k Denotes the minimum remaining CPU clock speed of the underlying network device k at all time slots; p K Denotes the K-th shortest path; Denotes the minimum remaining bandwidth of the K-th shortest path at all time slots; Y[j] denotes the set of subtasks j offloaded to the underlying network device k; SG r Denotes the topology graph of the service request obtained after performing the graph reconstruction step; Denotes the minimum remaining CPU clock speed of subtask i placed on the underlying network device k at all time slots; p e(i,j) Denotes the shortest path.

6. The computing offloading method for high-yield online dependency-aware services based on graph reconstruction according to claim 5, characterized in that: The optimization model for minimizing the total cost of all dependency-aware service requests in step S42 is: The constraints are as follows: Set Further optimize the optimization model to: The constraints are as follows:

7. The computing offloading method for high-yield online dependency-aware services based on graph reconstruction according to claim 6, characterized in that: The objective function in step S6 is: Maximize benefit(r) The constraints are:

Images