Task unloading method for association privacy quantification in edge computing

Abstract

The invention requests to protect a task unloading method for correlating privacy quantification in edge computing, and aims to optimize privacy protection and resource scheduling in a task unloading process. The strategy is realized through the following steps of: firstly, defining an associated privacy weight according to a security requirement of a subtask; secondly, establishing a directed acyclic graph (DAG) based on the dependency relationship among the subtasks; thirdly, establishing a calculation model for task unloading, including calculation of transmission delay, processing delay, energy consumption and the like; the task execution sequence is determined by calculating the priorities of the sub-tasks and the processor; and finally, scheduling each subtask based on a greedy thought, and allocating the subtask to the processor with the highest priority for processing. According to the strategy, the balance between privacy protection and task scheduling is considered, the risk of privacy disclosure can be effectively reduced, and the utilization of computing resources is optimized. The method is suitable for a computing task unloading scene with a complex task dependency relationship and privacy protection requirements.

Description

Technical Field

[0001] The present invention relates to the field of association privacy protection, and in particular to an association privacy quantification method and a task dependency and task offloading strategy. Background Art

[0002] With the development of cloud computing and edge computing, task offloading technology has gradually become one of the key technologies to improve the computing efficiency of smart devices and reduce device energy consumption. Task offloading means that due to the limitations of local device computing power and energy consumption, it is necessary to offload the complex computing tasks of local devices to edge computing nodes or the cloud, thereby utilizing their powerful computing power to provide users with lower latency and higher service quality.

[0003] However, there is a risk of privacy leakage during task offloading. When tasks containing user privacy information are offloaded to edge servers for execution, since edge servers are not necessarily reliable, user privacy is likely to be leaked, which in turn brings various risks to users. Therefore, how to effectively protect user privacy during task offloading has become an important research direction.

[0004] In most task offloading systems, privacy protection mechanisms usually focus on encryption technology or anonymization processing, but encryption technology often requires more computing resources, and with the development of quantum computers, privacy protection methods based on encryption technology are likely to become directly ineffective; privacy protection methods based on anonymization processing can also be reverse engineered by obtaining external data sets, resulting in the failure of privacy protection.

[0005] At the same time, existing privacy protection methods often ignore the risk of associated privacy leakage of tasks. Associated privacy refers to the privacy conflict between the private information contained in the task. For example, the user's bank card account exists in subtask t1, and the bank card password exists in subtask t2. At this time, there is a huge privacy conflict between the two subtasks. When the two subtasks t1 and t2 are offloaded to the same edge server, if this edge server has been occupied by an attacker, it will cause huge losses to the user's property; however, if the user's bank card account and the user's device battery level are offloaded to the edge server, the privacy conflict between the two subtasks is small and will not cause losses to the user's property. Most of the privacy protection mechanisms of existing task offloading systems do not take into account the associated privacy issues of tasks. The few methods that take into account the associated privacy issues simply give a privacy conflict set Y = {t1, t2, ..., t m}, and then restrict the generated offloading strategy not to be included in the set Y. This does not quantitatively analyze the association privacy, and imposes strong restrictions on the formulation of offloading decisions, which may lead to increased latency and energy consumption. Therefore, how to formulate a task offloading strategy for association privacy protection is a crucial issue.

[0006] Therefore, in order to better protect the associated privacy during the task offloading process and further reduce latency and energy consumption, the present invention quantitatively analyzes the associated privacy in combination with task dependency and proposes a task offloading method for quantifying associated privacy in edge computing.

[0007] After searching, the application publication number CN116866994A, Task offloading mechanism for protecting user privacy based on deep reinforcement learning in multi-user MEC system, belongs to the field of privacy protection technology. The steps are as follows: establish an adversary attack module to simulate the behavior of the adversary (i.e., untrusted MEC server) to obtain the user's usage pattern privacy and location privacy; a mechanism establishment module to simulate the wireless channel energy gain between the server and multiple users, the computing power and energy consumption limit of the user's device, and on this basis simulate local task calculation and edge task calculation, so as to establish a privacy protection mechanism; a mechanism optimization module to jointly optimize the user's computing speed and privacy protection, obtain stronger computing power and stronger privacy protection capabilities, and evaluate the performance of this algorithm.

[0008] The above invention protects the user's location privacy and usage mode privacy during task offloading, establishes an attacker model, a task offloading model, and a deep reinforcement learning model, and proposes a task offloading mechanism based on deep reinforcement learning to protect user privacy, but does not consider associated privacy, and the deep reinforcement learning model requires a large amount of training data and more computing resources. The present invention quantitatively analyzes associated privacy to better protect associated privacy, and combines task dependencies to further reduce latency and energy consumption, and finally uses an improved heuristic HEFT algorithm to quickly make an offloading decision. Summary of the invention

[0009] The present invention aims to solve the above problems of the prior art. A task offloading method associated with privacy quantification in edge computing is proposed. The technical solution of the present invention is as follows:

[0010] A task offloading method associated with privacy quantification in edge computing, comprising the following steps:

[0011] S1. Define the associated privacy weights of subtasks according to their different security requirements;

[0012] S2. Create a directed acyclic graph (DAG) based on the dependencies of the subtasks.

[0013] S3. Establish a computational model for task offloading;

[0014] S4. Calculate the priority of the subtask;

[0015] S5. Calculate the priority of the processor;

[0016] S6. Schedule each subtask in a cyclic manner based on the greedy idea.

[0017] Furthermore, in step S1, the associated privacy weights of the subtasks are defined according to the different security requirements of the subtasks, specifically including:

[0018] S11. According to the three different security requirements of the subtask: low, medium and high, three different associated privacy values ​​of the subtask are defined as: p l 、p m 、p h where p l <p m <p h ,The higher the weight is, the more privacy information a subtask contains, and the more likely it is to have privacy conflicts with other subtasks.

[0019] S12. According to the associated privacy value defined in step S11, assuming that the task offloading strategy is A 1:n =[a1,a2,...,a n ], defining the associated privacy of the task offloading strategy as

[0020]

[0021] Where A represents the offloading strategy of all subtasks, a i ,i=1,2,...,n represents the offloading decision of the i-th subtask, a i There are two values ​​0 or 1. i = 0, it means that this subtask is executed on the local device; when a i =1, it means that this subtask is offloaded to the edge server for execution. n is the total number of subtasks. P is the associated privacy, which represents the associated privacy leakage risk of this task offloading. The larger P is, the greater the risk. i Represents the associated privacy weight of the ith subtask.

[0022] Furthermore, in step S2, a directed acyclic graph DAG is established according to the dependency relationship of the subtasks, specifically including:

[0023] According to the data flow of subtasks within a task and their dependencies, a directed acyclic graph DAG is established. G = {V, E} is used to represent the DAG model. V is the set of subtasks, and the graph shows all nodes in the DAG. V = {t1, t2, ..., t n}, tj represents the jth subtask. E is the dependency relationship between subtasks, and the figure shows all the edges in the DAG.

[0024] Furthermore, in step S3, a calculation model for task offloading is established, which specifically includes:

[0025] S31. Calculate the task transmission delay based on the task data volume and task transmission rate;

[0026] S32. Calculate the task processing delay based on the number of CPU clock cycles and processor clock frequency required for the task;

[0027] S33. Establish a local processing model based on local processing delay;

[0028] S34. Establish an unloading processing model based on the unloading processing delay and the task transmission delay;

[0029] S35. Calculate local processing energy consumption based on local processing power;

[0030] S36. Calculate the energy consumption of unloading processing according to the transmit power and receive power;

[0031] Furthermore, in step S4, calculating the priority of the subtask specifically includes:

[0032] Subtask i The priority is calculated as follows:

[0033]

[0034] in Represents subtask t i The average computational cost of the set succ(t i ) represents subtask t i All subsequent tasks of Represents subtask t i Transmit data to t k The average communication cost when t i and t k On the same processor, c i,k =0; rank(t i ) represents the i The length of the critical path to the exit task. The larger the value, the higher the priority.

[0035] Furthermore, in step S5, calculating the priority of the processor specifically includes:

[0036] The processor priority is calculated as follows:

[0037] rank(t i ,qj )=EFT(t i ,q j )+jp i

[0038] Where EFT(t i ,q j ) represents subtask t i In processor q j The earliest completion time on , j = 0 or j = 1, when j = 0 q j represents the local processor, when j = 1, q j represents the edge server processor, p i is the subtask t defined in step S1 i The associated privacy value of rank(t i ,q j )The smaller the value, the lower the current processor cost and the higher the priority.

[0039] Furthermore, in step S6, each subtask is cyclically scheduled based on the greedy idea, specifically including:

[0040] According to the subtask priority calculated in step S4, all subtasks are sorted in non-increasing order, and each subtask is processed in turn according to the order of the subtasks. Then, according to the processor priority calculated in step S5, each subtask is assigned to the processor with the highest priority for execution until all subtasks are executed.

[0041] An electronic device, characterized in that it includes a memory, a processor, and a computer program stored in the memory and executable on the processor, wherein when the processor executes the program, it implements the task offloading method associated with privacy quantization in edge computing as described in any one of claims 1 to 7.

[0042] A non-transitory computer-readable storage medium having a computer program stored thereon, characterized in that when the computer program is executed by a processor, the task offloading method associated with privacy quantization in edge computing as described in any one of claims 1 to 7 is implemented.

[0043] A computer program product, comprising a computer program, characterized in that when the computer program is executed by a processor, it implements the task offloading method associated with privacy quantization in edge computing as described in any one of claims 1 to 7.

[0044] The advantages and beneficial effects of the present invention are as follows:

[0045] 1. Regarding privacy protection-related issues, existing privacy protection methods mainly include encryption and anonymization, but these methods focus on protecting location privacy and usage mode privacy, etc. Most of them do not consider the associated privacy of tasks, and those that do consider the associated privacy do not perform quantitative analysis on it. The present invention takes this into consideration, utilizes the different security requirements of subtasks, and quantitatively analyzes the associated privacy of subtasks. While protecting the associated privacy, it further reduces the latency by combining task dependencies.

[0046] 2. When using the HEFT algorithm to optimize the task offloading strategy, the standard algorithm process is to select the processor based on the earliest completion time of the task. The present invention improves the algorithm, comprehensively considers associated privacy, latency and energy consumption, and determines the priority of the processor based on these three factors, so that subtasks with larger associated privacy weights are more likely to be executed locally, thereby reducing the risk of associated privacy leakage. It also utilizes the lightweight, fast and efficient characteristics of the HEFT heuristic algorithm to make offloading decisions that are more in line with the characteristics of the edge environment. BRIEF DESCRIPTION OF THE DRAWINGS

[0047] Figure 1 It is a flow chart of the overall preferred embodiment provided by the present invention;

[0048] Figure 2 It is the dependency graph of subtasks;

[0049] Figure 3 Offload the model graph for the task;

[0050] Figure 4 Offload schematics for tasks;

[0051] Figure 5 It is the DAG graph of the instance task; DETAILED DESCRIPTION

[0052] The following will describe the technical solutions in the embodiments of the present invention in detail in conjunction with the accompanying drawings in the embodiments of the present invention. The described embodiments are only part of the embodiments of the present invention.

[0053] The technical solution of the present invention to solve the above technical problems is:

[0054] like Figure 1 As shown, the present invention provides a task offloading method associated with privacy quantization in edge computing, characterized by comprising the following steps:

[0055] S1. Define the associated privacy weights of subtasks according to their different security requirements;

[0056] S2. Create a directed acyclic graph (DAG) based on the dependencies of the subtasks.

[0057] S3. Establish a computational model for task offloading;

[0058] S4. Calculate the priority of the subtask;

[0059] S5. Calculate the priority of the processor;

[0060] S6. Schedule each subtask in a cyclic manner based on the greedy idea.

[0061] Furthermore, in step S1, the associated privacy weights of the subtasks are defined according to the different security requirements of the subtasks, specifically including:

[0062] S11. According to the three different security requirements of the subtask: low, medium and high, three different associated privacy values ​​of the subtask are defined as: p l 、p m 、p h where p l <p m <p h ,The higher the weight is, the more privacy information a subtask contains, and the more likely it is to have privacy conflicts with other subtasks.

[0063] S12. According to the associated privacy value defined in step S11, assuming that the task offloading strategy is A 1:n =[a1,a2,...,a n ], defining the associated privacy of the task offloading strategy as

[0064]

[0065] Where A represents the offloading strategy of all subtasks, a i ,i=1,2,...,n represents the offloading decision of the i-th subtask, a i There are two values ​​0 or 1. i = 0, it means that this subtask is executed on the local device; when a i =1, it means that this subtask is offloaded to the edge server for execution. n is the total number of subtasks. P is the associated privacy, which represents the associated privacy leakage risk of this task offloading. The larger P is, the greater the risk. i Represents the associated privacy weight of the ith subtask.

[0066] Furthermore, in step S2, a directed acyclic graph DAG is established according to the dependency relationship of the subtasks, specifically including:

[0067] like Figure 2 As shown in the figure, according to the data flow of subtasks within the task and their dependencies, a directed acyclic graph DAG is established, and G = {V, E} is used to represent the DAG model, V is the set of subtasks, and the figure shows all the nodes in the DAG, V = {t1, t2, ..., t n}, tj represents the jth subtask. E is the dependency relationship between subtasks, and the figure shows all the edges in the DAG. The start task is defined as a task without any predecessor task. Figure 2 In the example, t1 is the end task, and the end task is defined as a task without any successor task. Figure 2 The middle one is t9.

[0068] Furthermore, in step S3, a calculation model for task offloading is established, which specifically includes:

[0069] S31. Calculate the task transmission delay based on the task data volume and task transmission rate;

[0070] Upload tasks from local device i Transmission delay to edge server T i up Calculated by the following formula:

[0071]

[0072] Download task t from edge server i Transmission delay to local device T i down Calculated by the following formula:

[0073]

[0074] Where data i s Indicates the amount of data uploaded. Indicates the amount of data downloaded, R up Indicates the rate of uploading tasks, R down Indicates the rate of download tasks.

[0075] S32. Calculate the task processing delay based on the number of CPU clock cycles and processor clock frequency required for the task; Task t i Latency of processing in local device Calculated by the following formula:

[0076]

[0077] Task i The processing delay T at the edge server i s Calculated by the following formula:

[0078]

[0079] Among them Ψ i To process task t i The number of CPU clock cycles required, f lis the CPU clock frequency of the local device processor, f s is the CPU clock frequency of the edge server processor.

[0080] S33. Establish a local processing model based on local processing delay;

[0081] Subtask i Completion time FT of local device processing i l Calculated by the following formula:

[0082]

[0083] Among them, M i l is the available time of the local device processor, Calculated by the following formula:

[0084]

[0085] where pred(t i ) represents subtask t i The set of all predecessor tasks, from which we know that subtask t i Three conditions must be met before the local device can start processing: (1) Subtask t i All predecessor tasks of have been processed. (2) Subtask t i The processing results of all predecessor tasks have been transmitted to the local device. (3) The local device processor is currently idle and available.

[0086] S34. Establish an unloading processing model based on the unloading processing delay and the task transmission delay;

[0087] Subtask t i Offloading to the edge server for processing includes three stages: (1) sending stage, (2) processing stage, and (3) downloading stage. The following is a computational model for the above three stages.

[0088] (1) Sending phase

[0089] Subtask i The completion time of the sending phase FT i up Calculated by the following formula:

[0090]

[0091] in The available time for wireless channel upload, Calculated by the following formula:

[0092]

[0093] It can be seen that subtask t i Before the local device can start sending, two conditions must be met: (1) Subtask t i Among all the predecessor tasks, those subtasks processed on the local device have been completed. (2) Subtask t i Among all the predecessor tasks, the processing results of those tasks processed in the edge server have been transmitted to the local device.

[0094] (2) Processing stage

[0095] Subtask i Completion time FT of the processing stage i s Calculated by the following formula:

[0096]

[0097] in is the available time of the edge server's processor, Calculated by the following formula:

[0098]

[0099] It can be seen that subtask t i The edge server can start processing when three conditions are met: (1) subtask t i The sending phase has been completed. (2) Subtask t i The processing results of all predecessor tasks have been completed. (3) The processor of the edge server is currently idle and available.

[0100] (3) Downloading stage

[0101] Subtask i Completion time of the download phase FT i s Calculated by the following formula:

[0102]

[0103] in The available time for downloading on the wireless channel, Calculated by the following formula:

[0104]

[0105] It can be seen that subtask t i Before downloading can start through the wireless channel, two conditions must be met: (1) the wireless channel is currently idle. (2) Subtask t i The processing phase already on the edge server has been completed.

[0106] S35. Calculate local processing energy consumption based on local processing power;

[0107] Subtask i Energy consumption processed in local devices Calculated by the following formula:

[0108]

[0109] Where ρ is the power coefficient and ζ is a constant.

[0110] S36. Calculate the energy consumption of unloading processing according to the transmit power and receive power;

[0111] Subtask i Energy consumption offloaded to edge servers Calculated by the following formula:

[0112]

[0113] where g send is the transmit power of the local device, g rec is the received power of the local device.

[0114] Furthermore, in step S4, calculating the priority of the subtask specifically includes:

[0115] Subtask i The priority is calculated as follows:

[0116]

[0117] in Represents subtask t i The average computational cost of Calculated by the following formula:

[0118]

[0119] Where q is the number of processors, j = 0 or j = 1. When j = 0, it indicates the processor of the local device, and when j = 1, it indicates the processor of the edge server. i,j For subtask t i In processor q j The computational cost on i,j Calculated by the following formula:

[0120]

[0121] Among them, α and β are weight factors, which are used to control the importance of delay and energy consumption.

[0122] The set succ(t i ) represents subtask ti All subsequent tasks of Represents subtask t i Transmit data to t k The average communication cost, Calculated by the following formula:

[0123]

[0124] where c i,k From subtask t i Transmit Data k The communication cost is i and t k On the same processor, c i,k =0; rank(t i ) represents the i The length of the critical path to the exit task. The larger the value, the higher the priority.

[0125] Furthermore, in step S5, calculating the priority of the processor specifically includes:

[0126] The processor priority is calculated as follows:

[0127] rank(t i ,q j )=EFT(t i ,q j )+jp i

[0128] Where EFT(t i ,q j ) represents subtask t i In processor q j The earliest completion time, EFT(t i ,q j ) is calculated by the following formula:

[0129] EFT(t i ,q j )=EST(t i ,q j )+w i,j

[0130] Among them, EST(t i ,q j ) represents subtask t i In processor q j The earliest start time of processing, EST(t i ,q j ) is calculated by the following formula:

[0131]

[0132] Where AFT(t k ) represents subtask t k The actual completion processing time, AST(t k ) represents subtask t k The actual start processing time of subtask t k After the scheduling is completed, AFT(t k )=EFT(t k ), AST(t k )=EST(t k ).

[0133] Where j = 0 or j = 1, when j = 0, q j represents the local processor, when j = 1, q j represents the edge server processor, p i is the subtask t defined in step S1 i The associated privacy value of rank(t i ,q j )The smaller the value, the lower the current processor cost, the lower the associated privacy leakage risk, and the higher the priority.

[0134] Furthermore, in step S6, each subtask is cyclically scheduled based on the greedy idea, specifically including:

[0135] According to the subtask priority calculated in step S4, all subtasks are sorted in non-increasing order, and each subtask is processed in turn according to the order of the subtasks. Then, according to the processor priority calculated in step S5, each subtask is assigned to the processor with the highest priority for execution until all subtasks are executed.

[0136] The following is a specific example to further illustrate:

[0137] The DAG of the instance task is as follows Figure 5 As shown, there are four subtasks, and their related information is given in the following table:

[0138]

[0139] The privacy weight p i The default value is: p l =0,p m =100,p h =1000, and its specific size and proportion can be customized according to different privacy protection requirements of different users and actual conditions.

[0140] The meaning and value of each parameter are given in the following table:

[0141]

[0142] The following data can be calculated from the above information:

[0143]

[0144] Therefore, the priority order of subtasks at this time is: t1>t3>t2>t4.

[0145] We can further calculate the priority of each subtask corresponding to each processor:

[0146]

[0147]

[0148] The unloading decision can be obtained as follows:

[0149] <![CDATA[Subtask t i > decision making <![CDATA[t1]]> Edge Server Processing <![CDATA[t2]]> Edge Server Processing <![CDATA[t3]]> Local processing <![CDATA[t4]]> Local processing

[0150] From the offloading decision, it can be seen that subtask t1 can save time by executing it locally because the data is already in the local device at the beginning and the required computing resources are not many; although subtask t2 contains certain privacy data, it is not to the level of high risk and the required computing resources are relatively high, so it is necessary to offload it to the edge server with stronger computing power for execution to reduce latency; although subtask t3 requires high computing resources, its security requirements are also high, so it is arranged to be processed on the local device, reducing the risk of privacy leakage; subtask t4 is an exit task, and the required computing resources and data volume are very small, so executing it on the local device can save a lot of time.

[0151] In summary, the task offloading method of quantifying associated privacy in edge computing can not only protect associated privacy from the source, but also improve the lightweight heuristic algorithm HEFT, which can adapt to the delay-sensitive characteristics of the edge environment. At the same time, it takes into account task dependencies, and ensures the user's service quality while protecting associated privacy.

[0152] The systems, devices, modules or units described in the above embodiments may be implemented by computer chips or entities, or by products with certain functions. A typical implementation device is a computer. Specifically, the computer may be, for example, a personal computer, a laptop computer, a cellular phone, a camera phone, a smart phone, a personal digital assistant, a media player, a navigation device, an email device, a game console, a tablet computer, a wearable device, or a combination of any of these devices.

[0153] Computer readable media include permanent and non-permanent, removable and non-removable media that can be implemented by any method or technology to store information. Information can be computer readable instructions, data structures, program modules or other data. Examples of computer storage media include, but are not limited to, phase change memory (PRAM), static random access memory (SRAM), dynamic random access memory (DRAM), other types of random access memory (RAM), read-only memory (ROM), electrically erasable programmable read-only memory (EEPROM), flash memory or other memory technology, compact disk read-only memory (CD-ROM), digital versatile disk (DVD) or other optical storage, magnetic cassettes, magnetic tape magnetic disk storage or other magnetic storage devices or any other non-transmission media that can be used to store information that can be accessed by a computing device. As defined herein, computer readable media does not include temporary computer readable media (transitory media), such as modulated data signals and carrier waves.

[0154] It should also be noted that the terms "include", "comprises" or any other variations thereof are intended to cover non-exclusive inclusion, so that a process, method, commodity or device including a series of elements includes not only those elements, but also other elements not explicitly listed, or also includes elements inherent to such process, method, commodity or device. In the absence of more restrictions, the elements defined by the sentence "comprises a ..." do not exclude the existence of other identical elements in the process, method, commodity or device including the elements.

[0155] The above embodiments should be understood to be only used to illustrate the present invention and not to limit the protection scope of the present invention. After reading the contents of the present invention, technicians can make various changes or modifications to the present invention, and these equivalent changes and modifications also fall within the scope defined by the claims of the present invention.

Claims

1. A task offloading method associated with privacy quantification in edge computing, characterized in that: The following steps are involved: S1. Define the associated privacy weights of subtasks according to their different security requirements; S2. Create a directed acyclic graph (DAG) based on the dependencies of the subtasks; S3. Establish a computational model for task offloading; S4. Calculate the priority of the subtask; S5. Calculate the priority of the processor; S6. Schedule each subtask in a cyclic manner based on the greedy idea.

2. According to claim 1, a task offloading method associated with privacy quantification in edge computing is characterized in that: In step S1, the associated privacy weights of the subtasks are defined according to the different security requirements of the subtasks, specifically including: S11. According to the three different security requirements of subtasks in edge computing: low, medium and high, three different associated privacy values ​​of subtasks are defined as: p l 、p m 、p h where p l <p m <p h ,The higher the weight is, the more privacy information a subtask contains, and the more likely it is to have privacy conflicts with other subtasks. S12. According to the associated privacy value defined in step S11, assuming that the task offloading strategy is A 1:n =[a1,a2,...,a n ], defining the associated privacy of the task offloading strategy as Where A represents the offloading strategy of all subtasks, a i ,i=1,2,...,n represents the offloading decision of the i-th subtask, a i There are two values ​​0 or 1. i = 0, it means that this subtask is executed on the local device; when a i =1, it means that this subtask is offloaded to the edge server for execution. n is the total number of subtasks. P is the associated privacy, which represents the associated privacy leakage risk of this task offloading. The larger P is, the greater the risk. i Represents the associated privacy weight of the ith subtask.

3. The task offloading method associated with privacy quantification in edge computing according to claim 1 is characterized in that: In step S2, a directed acyclic graph DAG is established according to the dependency relationship of the subtasks, which specifically includes: According to the data flow of subtasks within a task and their dependencies, a directed acyclic graph DAG is established. G = {V, E} is used to represent the DAG model. V is the set of subtasks, and the graph shows all nodes in the DAG. V = {t1, t2, ..., t n }, t j represents the jth subtask. E is the dependency relationship between subtasks, and the figure shows all the edges in the DAG.

4. The method for offloading tasks associated with privacy quantification in edge computing according to claim 1, characterized in that: In step S3, a calculation model for task offloading is established, which specifically includes: S31. Calculate the task transmission delay based on the task data volume and task transmission rate; S32. Calculate the task processing delay based on the number of CPU clock cycles and processor clock frequency required for the task; S33. Establish a local processing model based on local processing delay; S34. Establish an unloading processing model based on the unloading processing delay and the task transmission delay; S35. Calculate local processing energy consumption based on local processing power; S36. Calculate the offloading processing energy consumption according to the sending power and the receiving power.

5. The method for offloading tasks associated with privacy quantification in edge computing according to claim 1, characterized in that: In step S4, calculating the priority of the subtask specifically includes: Subtask i The priority is calculated as follows: where w i Represents subtask t i The average computational cost of the set succ(t i ) represents subtask t i All subsequent tasks of Represents subtask t i Transmit data to t k The average communication cost when t i and t k On the same processor, c i,k =0; rank(t i ) represents the i The length of the critical path to the exit task. The larger the value, the higher the priority.

6. The method for offloading tasks associated with privacy quantification in edge computing according to claim 1, characterized in that: In step S5, calculating the priority of the processor specifically includes: The processor priority is calculated as follows: rank(t i ,q j )=EFT(t i ,q j )+jp i Where EFT(t i ,q j ) represents subtask t i In processor q j The earliest completion time on , j = 0 or j = 1, when j = 0 q j represents the local processor, when j = 1, q j represents the edge server processor, p i is the subtask t defined in step S1 i The associated privacy value of rank(t i ,q j )The smaller the value, the lower the current processor cost and the higher the priority.

7. The method for offloading tasks associated with privacy quantification in edge computing according to claim 1, characterized in that: In step S6, each subtask is scheduled cyclically based on the greedy idea, specifically including: According to the subtask priority calculated in step S4, all subtasks are sorted in non-increasing order, and each subtask is processed in turn according to the order of the subtasks. Then, according to the processor priority calculated in step S5, each subtask is assigned to the processor with the highest priority for execution until all subtasks are executed.

8. An electronic device, characterized in that: It includes a memory, a processor, and a computer program stored in the memory and executable on the processor. When the processor executes the program, it implements the task offloading method associated with privacy quantization in edge computing as described in any one of claims 1 to 7.

9. A non-transitory computer-readable storage medium having a computer program stored thereon, characterized in that: When the computer program is executed by a processor, it implements the task offloading method associated with privacy quantization in edge computing as described in any one of claims 1 to 7.

10. A computer program product, comprising a computer program, characterized in that When the computer program is executed by a processor, it implements the task offloading method associated with privacy quantization in edge computing as described in any one of claims 1 to 7.

Images