A task offloading method for privacy quantification in edge computing

Abstract

The application claims a task offloading method for privacy quantification in edge computing, aiming to optimize privacy protection and resource scheduling in the task offloading process. The strategy is implemented through the following steps: first, define the associated privacy weight according to the security requirements of subtasks; then, establish a directed acyclic graph (DAG) based on the dependency relationship between subtasks; next, establish a computing model for task offloading, including transmission delay, processing delay, energy consumption, etc.; calculate the priority of subtasks and processors to determine the order of task execution; finally, based on the idea of greed, schedule each subtask and assign it to the processor with the highest priority for processing. This strategy considers the balance between privacy protection and task scheduling, effectively reducing the risk of privacy leakage and optimizing the utilization of computing resources. It is suitable for computing task offloading scenarios with complex task dependency relationships and privacy protection requirements.

Description

TECHNICAL FIELD

[0001] The present application 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

[0002] With the development of cloud computing and edge computing, task offloading technology has gradually become one of the key technologies for improving the computing efficiency of intelligent devices and reducing the energy consumption of devices. Task offloading refers to the need to offload complex computing tasks of a local device to an edge computing node or a cloud end due to the limitations of the computing capacity and energy consumption of the local device, so as to utilize the powerful computing capacity to bring lower latency and higher service quality to users.

[0003] However, there is a risk of privacy leakage in the process of task offloading. When a task containing user privacy information is offloaded to an edge server for execution, the user's privacy is likely to be leaked because the edge server is not necessarily reliable, which will bring various risks to the user. Therefore, how to effectively protect the user's privacy in the task offloading process has become an important research direction.

[0004] In most task offloading systems, the privacy protection mechanism usually focuses 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 may directly fail; privacy protection methods based on anonymization processing can also be reverse engineered by obtaining external data sets, resulting in 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 privacy information contained in tasks, for example, a user's bank card number exists in sub-task t1, and a bank card password exists in sub-task t2. At this time, there is a huge privacy conflict between the two sub-tasks, and when the two sub-tasks t1 and t2 are offloaded to the same edge server, if the edge server has been occupied by an attacker, it will cause great loss to the user's property. However, if the user's bank card number and user device power are offloaded to the edge server, the privacy conflict between the two sub-tasks is small and will not cause loss to the user's property. The privacy protection mechanism of existing task offloading systems does not consider the associated privacy problem of tasks, and the method that considers the associated privacy problem only simply gives a privacy conflict set Y = {t1, t2,..., t m}, and then limit the generated offloading strategy from being included in the set Y. This does not perform quantitative analysis on associated privacy, and adds strong restrictions on the formulation of offloading decisions, which may cause latency and energy consumption to increase. Therefore, how to formulate a task offloading strategy for associated privacy protection is a crucial problem.

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

[0007] After searching, the application publication number CN116866994A, a task offloading mechanism for protecting user privacy based on deep reinforcement learning in a multi-user MEC system, belongs to the technical field of privacy protection. The steps are as follows: an enemy attack module is established to simulate the behavior of an enemy (i.e. an untrusted MEC server) obtaining user usage pattern privacy and location privacy; a mechanism establishment module is used to simulate the energy gain of the wireless channel between the server and the multiple users, the computing capacity and energy consumption limit of the user equipment, and on this basis, to simulate local task computing and edge task computing, thereby establishing a privacy protection mechanism; a mechanism optimization module is used to jointly optimize user computing speed and privacy protection, obtain stronger computing capacity and stronger privacy protection capacity, and evaluate the performance of the algorithm.

[0008] The above-mentioned application protects the location privacy and usage pattern privacy of users in the task offloading process, establishes an attacker model, a task offloading model and a deep reinforcement learning model, and proposes a task offloading mechanism for protecting user privacy based on deep reinforcement learning, but does not consider associated privacy, and the deep reinforcement learning model requires a large amount of training data and a large amount of computing resources. The present application quantitatively analyzes associated privacy to better protect associated privacy, and further reduces latency and energy consumption in combination with task dependency, and finally uses an improved heuristic HEFT algorithm to quickly formulate an offloading decision. SUMMARY

[0009] The present application aims to solve the problems of the above-mentioned prior art. A task offloading method for quantitative analysis of associated privacy in edge computing is proposed. The technical solution of the present application is as follows:

[0010] A task offloading method for quantitative analysis of associated privacy in edge computing, comprising the following steps:

[0011] S1. Defining the associated privacy weight of a subtask according to the different security requirements of the subtask;

[0012] S2. Establishing a directed acyclic graph (DAG) according to the dependency relationship of the subtasks;

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

[0014] S4. Calculate the priority of subtasks;

[0015] S5. Calculate the processor priority;

[0016] S6. Based on the greedy approach, schedule each subtask in a loop.

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

[0018] S11. Based on the three different security requirements of the sub-tasks: low, medium, and high, define three different associated privacy weights for the sub-tasks: p l p m p h Where p l <p m <p h The higher the weight, the more privacy information the subtask contains, and the more likely it is to cause privacy conflicts with other subtasks.

[0019] S12. Based on the associated privacy value defined in step S11, assume the task unloading policy is A. 1:n =[a1,a2,...,a n Define the associated privacy of the task unloading policy as follows:

[0020]

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

[0022] Furthermore, in step S2, a directed acyclic graph (DAG) is constructed based on the dependencies between subtasks, specifically including:

[0023] Based on the data flow and dependencies of the subtasks within the task, a directed acyclic graph (DAG) is constructed. The DAG model is represented by G = {V, E}, where V is the set of subtasks, and the graph contains all nodes in the DAG, V = {t1, t2, ..., t...}. n}, tj represents the jth subtask. E is the dependency relationship between subtasks, and all edges in the DAG in the figure.

[0024] Further, in the step S3, a computing model of task offloading is established, specifically comprising:

[0025] S31. Calculating task transmission delay according to task data volume and task transmission rate;

[0026] S32. Calculating task processing delay according to the number of CPU clock cycles required by the task and the processor clock frequency;

[0027] S33. Establishing a local processing model according to the local processing delay;

[0028] S34. Establishing an offloading processing model according to the offloading processing delay and the task transmission delay;

[0029] S35. Calculating local processing energy consumption according to local processing power;

[0030] S36. Calculating offloading processing energy consumption according to sending power and receiving power;

[0031] Further, in the step S4, the priority of the subtask is calculated, specifically comprising:

[0032] The priority of the subtask t i is calculated by the following formula:

[0033]

[0034] wherein represents the average computing cost of the subtask t i , the set succ(t i ) represents all successor tasks of the subtask t i , represents the average communication cost of the subtask t i transmitting data to t k , c i,k = 0 when t i and t k are on the same processor; rank(t i ) represents the length of the critical path from the subtask t i to the exit task, and the greater the value, the higher the priority.

[0035] Further, in the step S5, the priority of the processor is calculated, specifically comprising:

[0036] The priority of the processor is calculated by the following formula:

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

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

[0039] Further, in the step S6, each subtask is scheduled based on the greedy idea, specifically comprising:

[0040] According to the subtask priority calculated in step S4, all subtasks are sorted in a non-increasing order, each subtask is processed in turn according to the subtask order, and according to the processor priority calculated in step S5, each time the 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 comprises a memory, a processor and a computer program stored on the memory and executable on the processor, wherein the processor implements the task offloading method for associated privacy quantification in edge computing according to any one of claims 1 to 7 when executing the program.

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

[0043] A computer program product comprising a computer program, characterized in that the computer program, when executed by a processor, implements the task offloading method for associated privacy quantification in edge computing according to any one of claims 1 to 7.

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

[0045] 1. For privacy protection related problems, the existing privacy protection methods mainly include encryption and anonymization methods, but these methods mainly protect location privacy and usage pattern privacy, etc., most of which do not consider the associated privacy of the task, and those that consider the associated privacy do not perform quantitative analysis on it, the present application considers this, quantitatively analyzes the associated privacy of the subtask according to the different security requirements of the subtask, and further reduces the time delay while protecting the associated privacy in combination with the task dependency.

[0046] 2. When optimizing the task offloading strategy using the HEFT algorithm, the standard algorithm process is to select the processor according to the earliest completion time of the task, the present application improves the algorithm, comprehensively considers the associated privacy, the time delay and the energy consumption, and determines the priority of the processor according to the three, so that the subtask with greater associated privacy weight is more inclined to be executed locally, thereby reducing the risk of associated privacy leakage, and the characteristics of light weight, rapidness and high efficiency of the HEFT heuristic algorithm are utilized to make the offloading decision, which is more in line with the characteristics of the edge environment. BRIEF DESCRIPTION OF DRAWINGS

[0047] Figure 1 is the flowchart of the preferred embodiment of the present application as a whole;

[0048] Figure 2 is the dependency relationship diagram of the subtask;

[0049] Figure 3 is the task offloading model diagram;

[0050] Figure 4 is the task offloading principle diagram;

[0051] Figure 5 is the DAG diagram of the example task; DETAILED DESCRIPTION

[0052] The technical solutions in the embodiments of the present application will be described in detail below with reference to the drawings of the embodiments of the present application. The described embodiments are only a part of the embodiments of the present application.

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

[0054] As shown in Figure 1 , the present application is a task offloading method for associated privacy quantization in edge computing, characterized in that it comprises the following steps:

[0055] S1. Defining the associated privacy weight of the subtask according to the different security requirements of the subtask;

[0056] S2. Establishing a directed acyclic graph DAG according to the dependency relationship of the subtask;

[0057] S3. Establishing a computing model for task offloading;

[0058] S4. Calculate the priority of subtasks;

[0059] S5. Calculate the processor priority;

[0060] S6. Based on the greedy approach, schedule each subtask in a loop.

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

[0062] S11. Based on the three different security requirements of the sub-tasks: low, medium, and high, define three different associated privacy weights for the sub-tasks: p l p m p h Where p l <p m <p h The higher the weight, the more privacy information the subtask contains, and the more likely it is to cause privacy conflicts with other subtasks.

[0063] S12. Based on the associated privacy value defined in step S11, assume the task unloading policy is A. 1:n =[a1,a2,...,a n Define the associated privacy of the task unloading policy as follows:

[0064]

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

[0066] Furthermore, in step S2, a directed acyclic graph (DAG) is constructed based on the dependencies between subtasks, specifically including:

[0067] like Figure 2 As shown, a directed acyclic graph (DAG) is constructed based on the data flow and dependencies of the subtasks within the task. The DAG model is represented by G = {V, E}, where V is the set of subtasks, and the graph shows all nodes in the DAG, V = {t1, t2, ..., t...}. n}, tj represents the jthsubtask. E is the dependency relationship between subtasks, which is all edges in the DAG in the figure. The start task is defined as the task without any predecessor task, which is t1in Figure 2 . The end task is defined as the task without any successor task, which is t9in Figure 2 .

[0068] Further, in the step S3, a computing model of task offloading is established, specifically comprising:

[0069] S31. Calculate the task transmission delay according to the task data volume and the task transmission rate;

[0070] The transmission delay T i of the task t i from the local device to the edge server is calculated by the following formula: up

[0071]

[0072] The transmission delay T i of the task t i from the edge server to the local device is calculated by the following formula: down

[0073]

[0074] Wherein data i s represents the uploaded data volume, represents the downloaded data volume, R up represents the uploading task rate, R down represents the downloading task rate.

[0075] S32. Calculate the task processing delay according to the number of CPU clock cycles required by the task and the processor clock frequency; the task t i processing delay on the local device is calculated by the following formula:

[0076]

[0077] The task t i processing delay on the edge server T i s is calculated by the following formula:

[0078]

[0079] Wherein Ψ i is the number of CPU clock cycles required for processing the task t i , f lf is the CPU clock frequency of the local device processor. s This refers to the CPU clock frequency of the edge server processor.

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

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

[0082]

[0083] Where M i l The available time for the local device's 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 can know the subtask t i Three conditions must be met for local device processing to begin: (1) Subtask t i All preceding tasks have been completed. (2) Subtask t i The processing results of all previous 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 unloading processing delay and task transmission delay;

[0087] Subtask t i The offloading to the edge server for processing involves three stages: (1) sending stage; (2) processing stage; and (3) download stage. The computational models for these three stages are established below.

[0088] (1) Transmission phase

[0089] Subtask t i Completion time of the transmission phase (FT) i up Calculated by the following formula:

[0090]

[0091] in The available time for uploading via the wireless channel. Calculated by the following formula:

[0092]

[0093] Thus, subtask t i may start sending if two conditions are met: (1) all the predecessor tasks of subtask t i that are processed at the local device have been processed. (2) the results of all the predecessor tasks of subtask t i that are processed at the edge server have been transmitted to the local device.

[0094] (2) Processing phase

[0095] Thus, subtask t i may start processing if three conditions are met: (1) subtask t i has completed the sending phase. (2) the results of all the predecessor tasks of subtask t s have been processed. (3) the processor of the edge server is currently idle and available.

[0096]

[0097] where Tp is the available time of the processor of the edge server, is calculated by the following equation:

[0098]

[0099] Thus, subtask t i may start processing at the edge server if two conditions are met: (1) subtask t i has completed the sending phase. (2) the results of all the predecessor tasks of subtask t i have been processed. (3) the processor of the edge server is currently idle and available.

[0100] (3) Download phase

[0101] Thus, subtask t i may start downloading if two conditions are met: (1) the wireless channel is currently idle. (2) subtask t i has completed the processing phase at the edge server. s is calculated by the following equation:

[0102]

[0103] where Td is the available time of the wireless channel, is calculated by the following equation:

[0104]

[0105] Thus, subtask t i may start downloading through the wireless channel if two conditions are met: (1) the wireless channel is currently idle. (2) subtask t i has completed the processing phase at the edge server.

[0106] S35. Calculate the local processing energy consumption according to the local processing power;

[0107] Subtask t i Energy consumption of processing at local device is calculated by the following formula:

[0108]

[0109] where p is the power coefficient and z is a constant.

[0110] S36. Calculate the offloading processing energy consumption according to the sending power and the receiving power;

[0111] Subtask t i Energy consumption of processing at edge server is calculated by the following formula:

[0112]

[0113] where g send is the sending power of the local device, and g rec is the receiving power of the local device.

[0114] Further, in the step S4, the priority of the subtask is calculated, specifically comprising:

[0115] Subtask t i is calculated by the following formula:

[0116]

[0117] where represents the average calculation cost of the subtask t i , which is calculated by the following formula:

[0118]

[0119] where q is the number of processors, j=0 or j=1, when j=0, it represents the processor of the local device, when j=1, it represents the processor of the edge server, w i,j is the calculation cost of the subtask t i on the processor q j , w i,j is calculated by the following formula:

[0120]

[0121] where a and b are weight factors for controlling the importance of the delay and the energy consumption.

[0122] The set succ(t i ) represents the subtasks t​all the successor tasks of t represents the subtask t i transmit data to t k the average communication cost of t is calculated by the following formula:

[0123]

[0124] where c i,k is the communication cost of transmitting data t i from subtask t k to t i , c k = 0 when t i,k and t i are on the same processor; rank(t i ) represents the length of the critical path from subtask t i to the exit task, and the greater the value, the higher the priority.

[0125] Further, in the step S5, the priority of the processor is calculated, specifically comprising:

[0126] The priority of the processor is calculated by the following formula:

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

[0128] where EFT(t j ,q i ) represents the earliest finish time of subtask t j on processor q i , and EFT(t j ,q i,j ) is calculated by the following formula:

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

[0130] where EST(t j ,q k ) represents the earliest start processing time of subtask t k on processor q k , and EST(t k ,q k ) is calculated by the following formula:

[0131]

[0132] wherein AFT(t k ) represents the actual finish processing time of the subtask t k , AST(t k ) represents the actual start processing time of the subtask t k , when the subtask t k is scheduled to be completed, AFT(t k ) = EFT(t k ), AST(t k ) = EST(t k ).

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

[0134] Further, in the step S6, each subtask is scheduled based on the greedy idea, specifically comprising:

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

[0136] The following is further illustrated by a specific example:

[0137] The DAG of the example task is shown in FIG. 1, and there are four subtasks, the related information of which is given in the following table: Figure 5

[0138]

[0139] wherein the values of the privacy weight p i are defaulted as: p l = 0, p m = 100, p h = 1000, and the specific size and proportion can be customized according to different privacy protection requirements of different users and actual situations.

[0140] The meanings and values of the parameters are given in the following table:

[0141] ​

[0142] From the above information, the following data can be calculated:

[0143]

[0144] So the priority order of the sub-tasks at this time is: t1>t3>t2>t4.

[0145] Further, the priority of each sub-task corresponding to each processor can be calculated:

[0146]

[0147]

[0148] Thus, the offloading decision is:

[0149] Subtask t i ]]> Decision ​ Edge server processing [ t2 ] Edge server processing [ t3 ] Local processing [ t4 ] Local processing

[0150] As can be seen from the offloading decision, sub-task t1 can save time by being executed locally because the data is initially in the local device and the required computing resources are not much; sub-task t2 has certain private data, but it is not at a high risk level, and it requires higher computing resources, so offloading it to an edge server with stronger computing capability can reduce the latency; sub-task t3 has high computing resources required, but it also has high security requirements, so it is arranged to be processed on the local device to reduce the risk of privacy leakage; sub-task t4 is an exit task, and the required computing resources and data volume are small, so executing it on the local device can save a lot of time.

[0151] In summary, the task offloading method in the edge computing associated with privacy quantification not only protects associated privacy from the source, but also improves the lightweight heuristic algorithm HEFT, which can adapt to the time delay sensitive characteristics of the edge environment, and takes into account the task dependency, ensuring the quality of service of users while protecting associated privacy.

[0152] The systems, apparatuses, modules or units illustrated by the above embodiments can be specifically implemented by a computer chip or entity, or by a product with certain functions. A typical implementation device is a computer. Specifically, the computer may, for example, be 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 includes permanent and non-permanent, movable and non-movable media that can implement information storage by any method or technology. The 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 technologies, compact disc read-only memory (CD-ROM), digital versatile disc (DVD) or other optical storage, magnetic cassette, magnetic tape, magnetic disk storage or other magnetic storage devices, or any other non-transmission medium that can be used to store information accessible to a computing device. According to the definition herein, computer-readable media does not include transitory media such as modulated data signals and carriers.

[0154] It should also be noted that the terms "comprising", "comprising" or any other variants thereof are intended to cover non-exclusive inclusion, so that a process, method, article or apparatus including a series of elements includes not only those elements, but also other elements not explicitly listed or inherent to such a process, method, article or apparatus. Without more limitations, the element defined by the statement "comprising a" does not exclude the presence of additional identical elements in the process, method, article or apparatus including the element.

[0155] The above embodiments should be understood as only for illustrating the present application and not for limiting the protection scope of the present application. After reading the content of the present application, the skilled in the art can make various changes or modifications to the present application, and these equivalent changes and modifications also fall within the scope defined by the claims of the present application.

Claims

1. A task offloading method for associated privacy quantification in edge computing, characterized in that, Includes the following steps: S1. Define the associated privacy weights of subtasks based on their different security requirements; S2. Based on the dependencies between subtasks, construct a directed acyclic graph (DAG); S3. Establish a computational model for task unloading; S4. Calculate the priority of subtasks; S5. Calculate the processor priority; S6. Based on the greedy idea, each subtask is scheduled in a loop according to its priority and the processor's priority; In step S1, based on the different security requirements of the subtasks, the associated privacy weights of the subtasks are defined, specifically including: S11. Based on the three different security requirements of subtasks in edge computing: low, medium, and high, three different associated privacy values ​​for subtasks are defined as follows: , , in The higher the weight, the more privacy information the subtask contains, and the more likely it is to cause privacy conflicts with other subtasks. S12. Based on the associated privacy value defined in step S11, if the task uninstallation policy is set as follows: Define the associated privacy of the task unloading policy as follows: Where A represents the unloading strategy for all subtasks. This represents the unloading decision for the i-th subtask. , It has two possible values, 0 or 1, when When, it indicates that this subtask is executed on the local device; when When this occurs, it indicates that this subtask is offloaded to an edge server for execution; The total number of subtasks; To mitigate privacy concerns, this indicates a risk of privacy breaches associated with uninstalling the software for this task. The larger the value, the greater the risk. Representing the The associated privacy value of each sub-task; In step S3, the calculation model for task unloading is established, specifically including: S31. Calculate the task transmission delay based on the task data volume and task transmission rate; S32. Calculate the task processing latency based on the number of CPU clock cycles required by the task and the processor clock frequency; S33. Establish a local processing model based on local processing latency; S34. Establish an unloading processing model based on unloading processing delay and task transmission delay; S35. Calculate local processing energy consumption based on local processing power; S36. Calculate the offloading processing energy consumption based on the transmitting power and receiving power; In step S5, calculating the processor priority specifically includes: The processor priority is calculated by the following formula: in Representative subtask In processor The earliest completion time on the, or ,when hour Represents the local processor, when hour Represents edge server processors, For the subtasks defined in step S1 Related privacy values; A smaller value indicates a lower cost and higher priority for the current processor.

2. The task offloading method for associated privacy quantification in edge computing according to claim 1, characterized in that, In step S2, a directed acyclic graph (DAG) is constructed based on the dependencies between subtasks, specifically including: Based on the data flow and dependencies of the subtasks within the task, a directed acyclic graph (DAG) is constructed. Represents the DAG model. Let be the set of subtasks, represented by all nodes in the DAG in the graph. , This represents the i-th subtask. , The dependencies between subtasks are represented by all edges in the DAG in the graph.

3. The task offloading method for associated privacy quantification in edge computing according to claim 1, characterized in that, In step S4, calculating the priority of the subtask specifically includes: Subtask The priority is calculated by the following formula: in Subtasks Average computational cost, set Subtasks All subsequent tasks, Subtasks Transfer data to subtask The average communication cost when and On the same processor, ; Represents subtasks The length of the critical path to exiting the task; the larger the value, the higher the priority.

4. The task offloading method for associated privacy quantification in edge computing according to claim 1, characterized in that, In step S6, each subtask is cyclically scheduled based on a greedy approach, specifically including: Based on the subtask priorities calculated in step S4, all subtasks are sorted in non-increasing order. Each subtask is processed sequentially according to its order. Then, based on the processor priorities calculated in step S5, each subtask is assigned to the processor with the highest priority for execution until all subtasks have been executed.

5. An electronic device, characterized in that, It includes a memory, a processor, and a computer program stored on the memory and executable on the processor, wherein the processor, when executing the program, implements the task offloading method for associated privacy quantization in edge computing as described in any one of claims 1 to 4.

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

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

Images