5G MEC Computing Task Offloading Method Based on VCG Auction Mechanism

Abstract

The present invention relates to a 5G MEC computing task offloading method based on the VCG auction mechanism, comprising the following steps: Step S1; constructing a multi-task node and multi-edge node network system model; Step S2: based on the task scenario, according to the multi-task node and multi-edge node network system model, establishing a task scheduling problem with the goal of minimizing its own delay; Step S3: solving the task scheduling problem in Step S2 based on the VCG auction mechanism to obtain an optimal task offloading scheme. The present invention effectively improves the efficiency and quality of task offloading.

Description

Technical Field

[0001] The present invention relates to the technical field of computing offloading technology, and particularly relates to a 5G MEC computing task offloading method based on the VCG auction mechanism. Background Art

[0002] With the continuous development of the automation level of power systems, a large number of services such as detection, control, and monitoring have been applied to power systems in recent years. Although this real-time detection service can achieve instant perception of faults and automated management. However, the service has higher and higher requirements for network performance such as network service quality and request latency. Although the computing power of the task processing unit of new intelligent devices is getting stronger and stronger, it is still impossible to process huge application programs in a short time. In addition, local processing of these applications also faces another problem, namely the rapid consumption and self-loss of battery power. These problems seriously affect the operation efficiency and user experience of application programs on user devices. To solve the above problems, the industry has proposed mobile edge computing and computing offloading technology. Edge computing refers to deploying computing and storage resources at the network edge to provide an IT service environment and computing capabilities for mobile networks, thereby providing users with a network service solution with ultra-low latency and high bandwidth. As one of the key technologies in ECP, computing offloading refers to the technology in which a terminal device hands over some or all of its computing tasks to a cloud computing environment for processing, in order to solve the deficiencies of mobile devices in terms of resource storage, computing performance, and energy efficiency. Computing offloading technology mainly includes three aspects: offloading decision-making, resource allocation, and offloading system implementation. Among them, offloading decision-making mainly solves the problems of how the terminal decides to offload, how much to offload, and what to offload; resource allocation focuses on solving the problem of how the terminal allocates resources after offloading is achieved; for the implementation of the offloading system, it focuses on the implementation scheme during the user migration process. Summary of the Invention

[0003] In view of this, the purpose of the present invention is to provide a 5G MEC computing task offloading method based on the VCG auction mechanism, which can effectively improve the efficiency and quality of task offloading.

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

[0005] A 5G MEC computing task offloading method based on the VCG auction mechanism, comprising the following steps:

[0006] Step S1: Construct a multi-task node and multi-edge node network system model;

[0007] Step S2: Based on the task scenario, according to the multi-task node and multi-edge node network system model, establish a task scheduling problem with the goal of minimizing its own latency;

[0008] Step S3: Solve the task scheduling problem in Step S2 based on the VCG auction mechanism to obtain an optimal task offloading scheme.

[0009] Furthermore, the multi-task-node multi-edge-node network system model consists of multiple randomly distributed heterogeneous computing nodes ECPs, and these nodes have different computing resources and capabilities.

[0010] Furthermore, considering a quasi-static network scenario, that is, time is divided into time slots of the same size, and the network conditions and user distribution in each time slot are regarded as static and unchanged; in any specific time slot, each ECP is further divided into an idle state and a busy state; within each time slot, tasks are generated at the user equipment side and need to be processed; to complete the response and processing of tasks within the delay requirement, the tasks are processed at the local node or offloaded to a nearby ECP with stronger computing power, that is, task offloading;

[0011] It is stipulated that an ECP can calculate at most one task. If there is already a task being executed on the current ECP, other arriving tasks will be in the waiting queue;

[0012] It is assumed that the ECPs occupy orthogonal wireless channels, that is, there is no interference between different ECPs, and the ECPs serve the user equipment side through time division multiple access or frequency division multiple access

[0013] When the user equipment side transmits tasks to the same ECP, it will share or compete for communication resources. The time for transmitting subtasks from the user equipment side to the ECP is expressed as:

[0014]

[0015]

[0016] B k is the bandwidth occupied by node k, and g k is the channel gain between the user equipment side and node k. w is white noise. Here it is assumed that the ECP has all the channel state information;

[0017] The computing time is expressed by dividing the computing load by the computing power of the device, and both are expressed in CPU revolutions, as follows:

[0018]

[0019] f is the node computing rate, that is, the clock frequency of the CPU. It is assumed that each node can only calculate one task, and the remaining tasks to be executed are recorded in the waiting queue.

[0020] Furthermore, the specific content of Step S2 is as follows:

[0021] Step S21: Assume that each user service is relatively independent and consists of multiple subtasks, represented by the set W. Each user's task to be offloaded is defined as W = (A, D), where A represents the total set of n tasks, i.e., the task set, and D represents the relationships existing between the control flow and data flow among different tasks;

[0022] Step S22: Divide each subtask into two categories, namely those without a predecessor subtask and those with a predecessor subtask. For a subtask j without a predecessor subtask, i.e., this subtask is the first subtask to be executed for task R k , the start execution time is expressed as follows:

[0023]

[0024] where is the arrival time of task R k at the offloading node. is the end time of other tasks in the node Waiting queue; is the queuing time of this subtask at the offloading node; for a node j with a predecessor subtask, assume its predecessor subtask i belongs to the set i ∈ pred j , and the start execution time is expressed as:

[0025]

[0026] where is the completion time of the predecessor subtask, is the transmission delay of task j, is the queuing time;

[0027] For all subtask completion times, it is expressed as:

[0028]

[0029] For the complete task R k , its completion time is the end time of the last subtask, expressed as:

[0030]

[0031] From a global perspective, there are K tasks, so the system optimization objective is expressed as:

[0032]

[0033] Furthermore, the specific content of step S3 is as follows:

[0034] Step S31: Model the resource allocation and price strategy of ECP based on the buy-sell game theory;

[0035] Step S32: Based on the modeling in step S31, obtain the optimal offloading scheme.

[0036] Further, step S31 is specifically as follows:

[0037] The seller provides a computing task, that is, commodity j, and the minimum granularity of the commodity is a subtask; each task j corresponds to an evaluation value Value j ; each ASP maintains a subtask queue Subtask queue for tasks to be offloaded;

[0038] The ECP node is the bidder, and each node s has a cost value Cost for task j j , and there is also a Payment denoted as P j ;

[0039] Among them, the calculations of Value j and Cost j are as follows:

[0040]

[0041]

[0042] In order to combine the overall utility of the auction algorithm and the overall system delay, the following defines the maximum social welfare C social as:

[0043]

[0044] According to the definition of the VCG mechanism, the payment price calculation of the auction mechanism in the task offloading environment is as follows:

[0045]

[0046] θ is the bid decision of all nodes to be offloaded, and θ -s is the bid decision of all nodes to be offloaded except node s; let the revenues of the buyer and the seller be U s and U u respectively:

[0047] U u = Value j - P j

[0048] U s = P j - Cost j .

[0049] Further, step S32 is specifically as follows:

[0050] (1) Each ASP determines the subtask queue Subtask_queue to be offloaded under the current decision gap;

[0051] (2) Each subtask to be offloaded is published through the auctioneer, and the ECP conducts a combinatorial auction for all subtasks; calculates the valuation and cost values, runs the VCG mechanism to obtain the payment price Payment for each task;

[0052] (3) For each task, find max{U s}; determine the winning ECP, determine the final transaction price Payment and U u ;

[0053] (4) Judge whether U u >0; if so, calculate the offloading of subtask j; if not, deny the auction result and calculate locally;

[0054] (5) Repeat steps (1)-(4) in each decision gap until all tasks are offloaded.

[0055] The present invention has the following beneficial effects compared with the prior art:

[0056] 1. The present invention effectively improves the efficiency and quality of task offloading;

[0057] 2. The present invention models the problem as an auction problem, which can approximate the optimal solution in terms of two metrics: the average system delay and the number of beneficiary task nodes, thus taking into account both system interests and individual interests. Description of the Drawings

[0058] Figure 1 is the task offloading model of the present invention;

[0059] Figure 2 is the average system delay VS the number of task nodes in an embodiment of the present invention;

[0060] Figure 3 is the comparison between the auction algorithm and the optimal in an embodiment of the present invention;

[0061] Figure 4 is the number of beneficiary tasks VS the total number of tasks in an embodiment of the present invention;

[0062] Figure 5 is the algorithm running time in an embodiment of the present invention. Detailed Embodiment

[0063] The following further describes the present invention with reference to the drawings and embodiments.

[0064] Please refer to Figure 1 , the present invention provides a 5G MEC computing task offloading method based on the VCG auction mechanism, including the following steps:

[0065] Step S1: Construct a multi-task node and multi-edge node network system model;

[0066] Step S2: Based on the task scenario, according to the multi-task node and multi-edge node network system model, establish a task scheduling problem with the goal of minimizing its own latency;

[0067] Step S3: Solve the task scheduling problem in Step S2 based on the VCG auction mechanism to obtain the optimal task offloading scheme.

[0068] In this embodiment, the definition and properties of the auction mechanism are as follows:

[0069] It is represented by a triple (B, P, M), where B is the bidding space, P is the allocation rule, and M is the payment rule. The valuation space of the bidder is V. If the bidding space B exactly matches the valuation space V, the mechanism is called a direct mechanism. If there are differences, it may be that the mechanism design does not require the bidder to submit their valuation, or it is a problem with the mechanism design itself. When the private valuation information of the bidder is given, the central task of strategy analysis in mechanism design is to determine whether the bidder will truthfully report their valuation. The consistency of the bidding space does not mean that the bidder will definitely report their true value. If in a direct mechanism, the bidder reporting their true valuation is an equilibrium, then this direct mechanism has a truth-telling equilibrium. For the properties of mechanism design, the following definitions are as follows:

[0070] · Revelation principle: For any mechanism, there exists a direct mechanism with a truth-telling equilibrium such that the equilibrium result of the direct mechanism is the same as that of the original mechanism. The direct mechanism automatically completes the calculation of the equilibrium for the bidders, which is the meaning behind the revelation principle.

[0071] · Incentive compatibility: In a direct mechanism, if the allocation function is monotonically non-decreasing, that is, telling the truth always maximizes one's expected revenue, then this direct mechanism is incentive-compatible.

[0072] · Individual rationality: A direct mechanism is individually rational if the revenue for all bidders is non-negative.

[0073] · Revenue equivalence principle: If the direct mechanism (P, M) is incentive-compatible, then for all bidders and true valuations v i , their expected payments are only related to the allocation rule, and the payment rule determines a constant term. The revenue equivalence principle here no longer requires the assumption of symmetry. The four basic auction forms have the same allocation rule, that is, the highest bidder wins, so the expected payments of the bidders and the expected revenues of the sellers are the same.

[0074] If the direct mechanism (P,M) is incentive compatible, then for all bidders and true valuations v i , their expected payment is only related to the allocation rule, and the payment rule determines a constant term. (Note that symmetry is no longer required here.) Usually, the seller is the designer of the mechanism, so they often consider designing a mechanism that maximizes the expected revenue under the constraints of incentive compatibility and individual rationality. This mechanism is the optimal mechanism. The previous decision about pricing was: if the seller could know the true valuations of the bidders, they could simply sell at the highest valuation. However, since the seller does not know the true valuations, they need to use an estimation method to obtain the bids of the bidders. The value gap between the value estimated by the seller and the true value is the surplus value for the seller. Based on the valuation distribution function of the bidders, a model is constructed and the following mechanism is designed to make the seller's revenue optimal.

[0075] φ(x) = x - (1 - F(x)) / f(x)

[0076] The allocation rule is: the auction item is allocated to the bidder with the highest virtual value. If appropriate assumptions are made about this virtual value to satisfy the regular type assumption (the virtual value and the valuation are monotonically increasing functions), the optimal mechanism simplifies to:

[0077] · The allocation rule is: the auction item is allocated to the bidder with the highest virtual value.

[0078] · The payment rule is: collect the lowest possible valuation that guarantees his virtual value is the highest, that is

[0079] max(φ -1 (0), other's max value)

[0080] In this case, the optimal auction is a second-price auction with a reserve price of φ -1 (0). That is to say, each bidder will have a reserve price related to their valuation distribution, and this virtual value has been associated with the marginal value by some researchers. If there is symmetry among the bidders, then this reserve price is consistent with the optimal reserve price mentioned above. If regularity and symmetry are considered, then the second-price sealed auction with a reserve price of φ -1 (0) is the optimal mechanism.

[0081] In this embodiment, consider a heterogeneous network of a general multi-application service provider ASP (Application service provider) and multi-edge computing provider ECP (edge computing provider). This computing network consists of multiple randomly distributed heterogeneous computing nodes ECPs with different computing resources and capabilities. For ease of description and analysis, we consider a quasi-static network scenario, that is, time is divided into time slots of the same size, and the network conditions and user distributions in each time slot can be regarded as static and unchanged. In any specific time slot, each ECP can be further divided into an idle state and a busy state. In each time slot, the ASP generates tasks that need to be processed. To complete the response and processing of tasks within strict latency requirements, tasks may be processed on the local node or offloaded to a nearby ECP with stronger computing power, that is, task offloading.

[0082] It should be noted that we stipulate that an ECP can calculate at most one task. If there is already a task being executed on the current ECP, other arriving tasks will be in the waiting queue. Additionally, it should be noted that such a task offloading network has general significance and can be applied to different application scenarios. For an edge computing-enabled robot system, the ASP can be the robot performing the task, and the ECP can be idle robots, edge nodes, etc. in a room or factory. For a fog computing-enabled wireless communication network, the ASP can be a mobile user device, and the ECP can be an access point, base station, etc. equipped with a server nearby. For an intelligent transportation system, the ASP can be a moving vehicle, and the ECP can be a roadside unit, etc. For an intelligent home system, the ASP can be various sensors and devices, and the ECP can be a router, edge node, etc. in a room.

[0083] For ease of analysis, we assume there are k tasks, and each task is represented by the symbol R k Each task is represented by a binary tuple (z, h), where z represents the task size in bits, and h represents the task computing amount in CPU revolutions per second.

[0084] · Communication model

[0085] In terms of communication, we assume that orthogonal wireless channels are occupied between ECPs, that is, there is no interference between different ECPs. It is also assumed here that ECPs serve ASPs through Time Division Multiple Access (TDMA) or Frequency Division Multiple Access (FDMA), which is in line with most current wireless standards. Therefore, when an ASP transmits tasks to the same ECP, it will share or compete for communication resources such as time frames or resource blocks. In addition, it is assumed here that these tasks are not processed until all task data has been completely transmitted. Therefore, the time for transmitting subtasks from an ASP to an ECP can be expressed as:

[0086]

[0087]

[0088] B k is the bandwidth occupied by node k, and g k is the channel gain between the ASP and node k. w is white noise. It is assumed here that the ECP has all the channel state information.

[0089] · Computational model

[0090] In terms of computing, the computing time can be expressed by dividing the computing load by the computing power of the device, and both can be expressed in terms of CPU revolutions per minute, as follows:

[0091]

[0092] f is the node computing rate, that is, the clock frequency of the CPU (CPU revolutions per second). It is assumed that each node can only compute one task, and the remaining tasks to be executed are recorded in the waiting queue.

[0093] In this embodiment, it is assumed that each user service is relatively independent and consists of multiple subtasks, which is represented by the set W. Each user's task to be offloaded is defined as W = (A, D), where A represents the total set of n multiple tasks, that is, the task set, and D represents the relationships existing between the control flow and data flow among different tasks.

[0094] Each subtask is divided into two categories, namely those without a predecessor subtask and those with a predecessor subtask. For a subtask j without a predecessor subtask, that is, this subtask is the first subtask to be executed for task R k its start execution time is expressed as follows:

[0095]

[0096] Among them, is the arrival time of task R k at the offloading node. is the end time of other tasks in the node Waiting queue. is the queuing time of this subtask at the offloading node. For node j with a predecessor subtask, assume its predecessor subtask i belongs to the set i∈pred j . Its execution start time can be expressed as:

[0097]

[0098] where is the completion time of the predecessor subtask, is the transmission delay of task j, is the queuing time. Based on the above, for all subtask completion times can be expressed as:

[0099]

[0100] For the complete task R k , its completion time is the end time of the last subtask, which can be expressed as:

[0101]

[0102] From a global perspective, there are K tasks, so the system optimization goal can be expressed as:

[0103]

[0104] In this embodiment, the VCG auction mechanism is specifically:

[0105] In a time-varying ECP environment, to provide differentiated computing services, the service provider (ECP) is used as the buyer (bidder), and commodity bids are generated through its own computing and communication capabilities. The user equipment side (ASP) is used as the seller, and according to the task size and the required computing power, it differentiates the valuation (cost value) for the task; the higher the seller quotes for the task computing resources, the higher the value of the task itself, and the higher the unit resource revenue obtained from offloading the computing. However, too high a valuation will reduce the buyer's willingness to purchase, thus processing more computing tasks at the local terminal, resulting in the idle of ECP resources and the backlog of the ASP queue. Therefore, there is a non-cooperative game between the buyer and the seller, and there is a trade-off relationship between the offloading revenue and the offloading delay of the mobile terminal. Next, the resource allocation and price strategy of the ECP will be modeled based on the buyer-seller game theory.

[0106] · The seller provides computing task j (commodity). The minimum granularity of the commodity is the subtask. Each task j corresponds to a valuation Value j . Each ASP maintains a queue of tasks to be offloaded, Subtask queue.

[0107] · The ECP node is the bidder. Each node s has a cost value Cost for task j j . There is also a Payment (bid) denoted as P j .

[0108] Among them, Value j and Cost j are calculated as follows:

[0109]

[0110]

[0111] In order to combine the overall utility of the auction algorithm and the overall system delay, the following defines the maximum social welfare C social as:

[0112]

[0113] According to the VCG mechanism definition, the payment price calculation of the auction mechanism in the task offloading environment is as follows:

[0114]

[0115] θ is the bid decision of all nodes to be offloaded, and θ -s is the bid decision of all nodes to be offloaded except node s. Let the revenues of the buyer and the seller be U s and U u respectively:

[0116] U u = Value j - P j

[0117] U s = P j - Cost j

[0118] In this embodiment, the task offloading model is as Figure 1 . The auction process is divided into the following five steps:

[0119] 1. Each ASP determines the subtask queue Subtask_queue to be offloaded under the current decision gap.

[0120] 2. Each subtask to be offloaded is released by the auctioneer, and the ECP conducts a combinatorial auction for all subtasks. Calculate the valuation and cost values (Cost and Value). Run the VCG mechanism to obtain the payment price (Payment) for each task.

[0121] 3. For each task, find max{Us}. Determine the winning ECP (acquire the lot). Determine the final transaction price Payment and U u .

[0122] 4. Judge U u > 0. If so, offload and calculate subtask j. If not, deny the auction result and calculate locally.

[0123] 5. Repeat steps 1 - 4 at each decision interval until all tasks are offloaded.

[0124] In this embodiment, a 5G MEC computing task offloading system based on the VCG auction mechanism is further provided, including a user device (ASP), an edge service node (ECP), and an auctioneer.

[0125] Each role needs to perform corresponding functions to maintain the normal operation of the system. Next, key issues in the specific implementation of the proposed model are analyzed, and corresponding supporting technology directions are given.

[0126] The ASP offloads computing tasks to the edge network, pre - processes application requests or directly responds in the area close to the user, minimizing data transmission volume as much as possible, reducing the response latency of the application, and enhancing the user experience. In the actual execution process, the ASP also needs to solve two technical problems: on the one hand, it is the application management problem brought by task offloading, involving task splitting, data synchronization, fault - tolerance design, etc.; on the other hand, it is the security problem brought by edge computing, mainly how to ensure data privacy security when the ECP executes computing tasks.

[0127] Based on the VCG bidding strategy, the ECP can exchange idle system resources for benefits. However, to become an ECP, certain conditions need to be met: on the one hand, since the provided edge computing service is for ASP users, the computing resources must reach a certain scale to match the task requirements; on the other hand, the computing resources need to be guaranteed to be available for a long time to ensure the stability of the edge computing service. Like the ASP, the ECP also faces security challenges: it needs to ensure the secure execution of the computing tasks it undertakes, prevent external intrusion, and at the same time guard against attackers disguising as ASPs and using malicious task codes for internal network penetration.

[0128] The auctioneer, as the center of task offloading, is the key to the realization of the auction process. For the ASP, the auctioneer provides services on behalf of all ECPs in the region; for the ECP, the auctioneer organizes the bidding, runs the VCG mechanism, and determines the winner. The auctioneer must obtain the recognition of all ECPs to ensure the fairness of task offloading. Specifically, the auctioneer needs to perform the following duties: (1) For ECPs that meet the task requirements, release task information equally and provide a fair competition opportunity; (2) Execute the winner determination and price calculation fairly according to the established auction algorithm; (3) Maintain the contract and settle accounts according to the task completion situation. However, each ECP belongs to a different institution, and it is very difficult to select a commonly trusted third party as the auctioneer. The establishment of the auctioneer is essentially to build a consensus mechanism in an untrusted distributed environment. To address this problem, blockchain technology

[29] provides an effective solution. All ECPs in the same region can jointly build a consortium chain, such as Hyperledger Fabric

[30] , and then elect an auctioneer through voting and write the auction algorithm into the configuration rules. The information of each auction, including task information, bidding information, auction results, etc., is written into the blockchain ledger as a transaction record.

[0129] Embodiment 1:

[0130] In this embodiment, the performance of the VCG auction algorithm is evaluated through simulation. Consider a square area of 80m * 80m and divide it into 16 grids of 4 * 4. Randomly deploy an edge node in each grid. Each node not only has rich communication resources but also has powerful computing capabilities. The coverage range of each helper node is 20m, the bandwidth is 5MHz, and the computing power is 5GHz. Task nodes are randomly distributed in this area. To consider the heterogeneity of task nodes and tasks: (1) The size and processing density of computing tasks are randomly selected from [500, 5000] KB and [500, 3000] cycle / bit respectively; (2) The computing power of task nodes is randomly selected from [0.8, 0.9, 1.0, 1.1, 1.2] GHz. Tasks are default created as a task set with a length of 3. In addition, the transmission rate of all task nodes is set to 100mW, and the noise power of the channel is set to -100dBm. The channel gain is modeled as where is the distance between task node n and helper node k, and a = 4 is the path loss coefficient.

[0131] Figure 2 The performance of this method and the following benchmark methods in terms of the system average delay is compared:

[0132] · Local computing (Local): Each task node processes its computing tasks on the local device.

[0133] · Random offloading: Each task node randomly offloads its computing tasks to a certain helper node or processes them on the local device.

[0134] · Optimal offloading: The cross-entropy method is used to obtain the solution that minimizes the average system delay.

[0135] As Figure 3 shown, the average system delay increases with the growth of the number of task nodes. However, this task offloading algorithm can always achieve an approximately optimal average system delay and reduce a large amount of delay compared with local computing, maximum data transfer rate offloading, and random offloading.

[0136] A beneficiary task refers to a task whose task processing delay can be reduced through task offloading (compared with local computing). Therefore, this metric answers the question of how many tasks can benefit from task offloading. So, the number of beneficiary tasks can not only reflect the delay performance at the individual level but also reflect the satisfaction with the task offloading results from the individual aspect.

[0137] Figure 4 The performance of this method and the benchmark method in terms of the number of beneficiary tasks is compared. As Figure 4 shown, the number of beneficiary tasks obtained by the auction algorithm increases with the increase in the total number of tasks until it levels off. Moreover, compared with the benchmark method, the auction algorithm can always obtain approximately the same number of beneficiary task nodes.

[0138] Figure 5 The execution times of this method and the optimal algorithm (cross-entropy algorithm) are compared. The time complexity of the auction algorithm is much lower than that of the cross-entropy algorithm. If it is assumed that there are N tasks and M edge servers in the system. When the auction algorithm is executed, each server needs to quote for each task, and when calculating the payment price using VCG, it is also necessary to traverse M servers. Therefore, the time complexity of the algorithm is: O(NM 2 ).

[0139] The above are only the preferred embodiments of the present invention. All equivalent changes and modifications made according to the scope of the patent application of the present invention shall fall within the scope of the present invention.

Claims

1. A 5G MEC computing task offloading method based on the VCG auction mechanism, characterized in that, it includes the following steps: Step S1; Construct a multi-task node multi-edge node network system model; Step S2: Based on the task scenario, according to the multi-task node multi-edge node network system model, establish a task scheduling problem with the goal of minimizing its own delay; Step S3: Solve the task scheduling problem in Step S2 based on the VCG auction mechanism to obtain the optimal task offloading scheme; The specific content of Step S3 is: Step S31: Model the resource allocation and price strategy of the ECP based on the buyer-seller game theory; Step S32: Based on the modeling in Step S31, obtain the optimal offloading scheme; The specific content of Step S31 is: The seller provides computing tasks, namely commodity j, and the minimum granularity of the commodity is a subtask; each task j corresponds to an estimated value Value j ; each ASP maintains a task queue to be offloaded, Subtaskqueue; The ECP node is the bidder, and each node s has a cost value Cost for task j j , and there is also a Payment denoted as P j ; Among them, Value j and Cost j are calculated as follows: To combine the overall utility of the auction algorithm and the overall system delay, the maximum social welfare C is defined as follows: social is defined as: According to the definition of the VCG mechanism, the payment price of the auction mechanism in the task offloading environment is calculated as follows: θ is the bidding decision of all nodes to be offloaded, θ -s is the bidding decision of all nodes to be offloaded except node s; let the revenues of the buyer and the seller be U s and U u respectively: U u = Value j - P j U s = P j - Cost j ; The specific content of Step S32 is: (1) Each ASP determines the task queue to be offloaded Subtask_queue under the current decision gap; (2) Each subtask to be offloaded is released by the auctioneer, and the ECP conducts a combined auction for all subtasks; calculate the valuation and cost value, and run the VCG mechanism to obtain the payment price Payment for each task; (3) For each task, find max{U s}; determine the winning ECP, determine the final transaction price Payment and U u ; (4) Judge U u > 0; if so, offload and calculate subtask j; if not, deny the auction result and calculate locally; (5) Repeat (1)-(4) in each decision gap until all tasks are offloaded.

2. The 5G MEC computing task offloading method based on the VCG auction mechanism according to claim 1, characterized in that, the multi-task node multi-edge node network system model includes multiple randomly distributed heterogeneous computing nodes ECPs, and these nodes have different computing resources and capabilities.

3. The 5G MEC computing task offloading method based on the VCG auction mechanism according to claim 2, characterized in that, Consider a quasi-static network scenario, that is, the time is divided into time slots of the same size, and the network conditions and user distributions in each time slot are regarded as static and unchanged; in any specific time slot, each ECP is further divided into an idle state and a busy state; within each time slot, tasks are generated at the user equipment side and need to be processed; To complete the response and processing of tasks within the delay requirement, tasks are processed locally at the node or offloaded to a nearby ECP with stronger computing power for processing, that is, task offloading; It is stipulated that an ECP can calculate at most one task. If there is already a task being executed on the current ECP, other arriving tasks will be in the waiting queue; It is assumed that the ECPs occupy orthogonal wireless channels, that is, there is no interference between different ECPs, and the ECPs serve the user equipment side through time division multiple access or frequency division multiple access; When the user equipment side transmits tasks to the same ECP, it will share or compete for communication resources. The time for transmitting subtasks from the user equipment side to the ECP is expressed as: B k is the bandwidth occupied by node k, g k is the channel gain between the user equipment side and node k; w is white noise; Here it is assumed that the ECP has all the channel state information; The computing time is expressed by dividing the computing load by the computing power of the device, and both are expressed in CPU revolutions, as follows: f is the node computing rate, that is, the clock frequency of the CPU. It is assumed that each node can only calculate one task, and the remaining tasks to be executed are recorded in the waiting queue.

4. The 5G MEC computing task offloading method based on the VCG auction mechanism according to claim 3, characterized in that, the specific steps of step S2 are as follows: Step S21: Assume that each user service is relatively independent and consists of multiple subtasks, which are represented by the set W; each user's task to be offloaded is defined as W = (A, D), where A represents the total set of n multiple tasks, that is, the task set, and D represents the relationships existing between the control flow and data flow among different tasks; Step S22: Divide each subtask into two categories, namely those without a predecessor subtask and those with a predecessor subtask. For a subtask j without a predecessor, that is, this subtask is the first subtask to be executed in task R k , the start execution time is expressed as follows: Among them, is the arrival time of task R k at the unloading node; is the end time of other tasks in the node Waitingqueue; is the queuing time of this subtask at the unloading node; for subtask j with a predecessor, let its predecessor subtask i belong to the set i∈pred j , the execution start time of subtask j is expressed as: wherein is the completion time of the previous subtask, is the transmission delay of task j, is the queuing time; The completion time for all subtasks is expressed as: For the complete task R k , its completion time is the end time of the last subtask, expressed as: From a global perspective, there are K tasks, so the system optimization objective is expressed as:

Images