A task offloading method in a multi-user access intelligent edge computing system

Abstract

The present invention discloses an embodiment of the present invention, which provides a task offloading method for a multi-user access intelligent edge computing system, which is applied to terminal nodes and edge server nodes and relates to the technical field of industrial Internet of Things. By classifying tasks into delay-sensitive, computationally complex, and terminal task types, the problem of node computing resource mismatch caused by unclear business types is optimized, and the overall processing efficiency of the edge computing system is improved; and the original task is divided into subtasks that can be executed independently, which effectively reduces the calculation and waiting delays caused by excessive task volume and reduces the coupling between task completions; the edge server node models the task offloading process, and reasonably judges the task offloading decision and offloading location based on the historical processing data of the task calculation, effectively shortening the calculation delay caused by the long task processing waiting queue, and meeting the requirement of minimizing energy loss as much as possible within the delay constraint.

Description

Technical Field

[0001] The present invention relates to the technical field of industrial Internet of Things, and in particular to a task offloading method in an intelligent edge computing system with multi-user access. Background Art

[0002] With the proliferation of connected smart IoT devices and the increasing complexity of computing tasks, terminal networks are generating massive amounts of sensory and computational data. The large volume of services accessing computing networks and the resulting data are placing significant pressure on network bandwidth and the computing capabilities of computing centers. Traditional cloud computing models transmit all collected sensory data to cloud centers for processing, potentially leading to high response latency, high transmission energy consumption, and privacy leaks. Furthermore, IoT uplink rates are latency-sensitive, placing high latency constraints on the coordinated completion of tasks. Therefore, edge computing technology offloads some tasks to the edge, reducing communication transmission latency, preventing privacy leaks, and ultimately reducing task computation time by shortening communication link processing time.

[0003] Compute offloading is a key technology in edge computing. Due to the limited computing power of end devices, they are typically unable to complete all tasks independently. Therefore, tasks need to be offloaded to edge computing servers or cloud servers, leveraging more abundant computing resources. Offloading all tasks to a single service node often causes congestion at that node, creating long queues and wasting computing resources at other nodes. Randomly offloading tasks results in high transmission latency during communication, hindering overall task completion latency. Therefore, compute offloading involves making rational task offloading decisions, comprehensively analyzing node and task conditions, and deciding whether to offload tasks and which node to offload the target task to.

[0004] Existing techniques typically collect data from multiple edge servers and mobile terminals, then make decisions based on the goal of minimizing terminal energy consumption and the computing power of network devices. A Markov decision process is then used to model the optimal strategy, translating the pros and cons of each strategy into the size of the final reported data. However, this approach focuses solely on minimizing energy consumption, ignoring latency-sensitive tasks in the Industrial Internet of Things. Furthermore, the use of a Markov process for modeling ignores the impact of the decision-making process's duration on the modeling process. Summary of the Invention

[0005] The purpose of the present invention is to solve the problems of the above-mentioned background technology and to propose a task offloading method in an intelligent edge computing system with multi-user access.

[0006] The purpose of the present invention can be achieved through the following technical solutions:

[0007] In a first aspect of an embodiment of the present invention, a task offloading method for a multi-user access intelligent edge computing system is provided, which is applied to a terminal node. The method includes:

[0008] Obtaining data collected by sensors connected to the terminal node to generate an original task to be calculated, and determining whether the original task meets a local offloading condition;

[0009] If the original task meets the local offloading condition, the original task is split and sorted into a linear task queue containing multiple subtasks;

[0010] The task type of each subtask is determined based on its task complexity and expected completion delay; the task types include delay-sensitive type, computational complexity type, and terminal task type; the terminal task type indicates that the task complexity of the subtask is less than a preset task complexity threshold, and the expected completion delay of the subtask is less than a preset delay-sensitive threshold; the computational complexity type indicates that the task complexity of the subtask is not less than a preset task complexity threshold; the delay-sensitive type indicates that the task complexity of the subtask is less than a preset task complexity threshold, and the expected completion delay of the subtask is not less than a preset delay-sensitive threshold;

[0011] For each subtask, if the subtask is of the terminal task type, the subtask is processed; if the subtask is of the computationally complex type, the subtask is unloaded to the cloud server node so that the cloud server node processes the subtask; if the subtask is of the delay-sensitive type, the subtask is unloaded to the edge server node so that the edge server node models the decision-making process of the subtask to obtain the optimal offloading decision of the subtask, so that the overall benefit of the joint optimization of energy consumption and delay in processing the subtask is maximized, and the subtask is processed, or the subtask is unloaded to the cloud server node so that the cloud server node processes the subtask.

[0012] Optionally, before dividing and sorting the original task into a linear task queue containing a plurality of subtasks, the method further includes:

[0013] Calculate the actual start time AST(j) of the original task:

[0014] AST(j)=max{avail{0∪[k]},max(AFT(j')+C jj' )}

[0015] Wherein, avail{0∪[k]} represents the earliest ready execution time of the terminal node or the cloud server node k, j' represents the predecessor tasks of all the original tasks, C jj' represents the scheduling time of task j' and task j' results;

[0016] The actual end time of predecessor task j' is AFT(j'):

[0017] AFT(j')=min{D p (j')+AST(j')}

[0018] Among them, D p (j') is the execution time of the predecessor task;

[0019] Iterate the current task end time from all associated predecessor task results, and calculate the actual completion time AFT of the original task on the cloud server node respectively. sever (j) and the actual completion time AFT at the terminal node local (j);

[0020] Determine whether the original task meets the local offloading conditions. If AFT sever (j)≤AFT local (j) If the original task does not meet the local offloading condition, the original task is offloaded to the cloud server node so that the cloud server node processes the original task; otherwise, the original task meets the local offloading condition.

[0021] Optionally, if the original task meets the local offloading condition, the original task is divided and sorted into a linear task queue containing multiple subtasks. The method includes:

[0022] The original task as a whole is topologically divided according to the inheritance and parallelism of the tasks; the inheritance of the tasks means that the execution of the subsequent tasks depends on the completion of the predecessor tasks; the parallelism of the tasks means that there is no logical dependency between the execution of the two tasks;

[0023] Solve the target task that minimizes the completion time of the original task:

[0024]

[0025] Where a(s) represents the action taken in state s, and N is the total number of system tasks;

[0026] The task with the shortest processing time is selected as the first task to be executed in the priority queue. When the tasks are divided and arranged into a linear queue, the priority of the subsequent tasks must be lower than that of the predecessor tasks.

[0027] Design a subtask priority sorting algorithm to integrate subtasks into a linear queue of pending tasks:

[0028] Calculate the priority of subtask j:

[0029] Rank(j)=D t (j)+max(R m +Rank(j'))

[0030] Among them, D t (j) is the processing time of subtask j, R m is the processing time of all predecessor tasks, Rank(j') is the processing time of the predecessor tasks that have an inheritance relationship with subtask j;

[0031] Sort all subtasks in descending order of priority to obtain a linear task queue.

[0032] Optionally, the edge server node and the terminal node are collectively referred to as the edge side;

[0033] Determine the task type of each subtask based on its complexity and expected completion delay, including:

[0034] According to the computing resources and computing power of the edge side, combined with the execution of tasks of different complexity, the upper limit of the comprehensive complexity that the edge side can withstand is determined as α max ;

[0035] According to the time and algorithm complexity of each subtask, the comprehensive complexity of task i is determined to be α i ;

[0036] According to the delay constraint requirements of each subtask, determine the delay threshold t of the subtask max ;

[0037] Calculate the completion time t of each subtask ij ;

[0038] According to α max , α i , t max and t ij The relationship between them determines the task type of the subtask.

[0039] Optionally, calculate the completion time t of each subtask ij ,include:

[0040] Calculate the channel transmission power:

[0041]

[0042] Among them, g ij represents the channel gain from the terminal node i to the cloud server node j, B is the bandwidth, N0 is the white noise power, and p is the transmit power;

[0043] Split the completion time of each subtask into transmission time and calculation time

[0044] Calculate the transmission time of this subtask

[0045]

[0046] Among them, m i Indicates the total amount of data that needs to be transferred;

[0047] Calculate the computation time of the task

[0048]

[0049] Among them, c i Indicates the number of CPU cycles required to process each subtask, f ij Indicates the computing resources allocated by the server to this subtask,

[0050] Calculate the total task completion time:

[0051]

[0052] In a second aspect of an embodiment of the present invention, a task offloading method for a multi-user access intelligent edge computing system is provided, which is applied to an edge server node. The method includes:

[0053] Receive a target subtask sent by a terminal node; the target subtask is a delay-sensitive subtask in the linear task queue of the terminal node, whose task type is determined according to the task complexity and expected completion delay of each subtask; the linear task queue of the terminal node is a task queue containing multiple subtasks obtained by the terminal node by splitting and sorting and integrating the original task that meets the local unloading conditions; the original task is a task collected by the sensor connected to the terminal node; the task types include delay-sensitive, computational complexity and terminal task types; the terminal task type indicates that the task complexity of the subtask is less than a preset task complexity threshold, and the expected completion delay of the subtask is less than the preset delay-sensitive threshold; the computational complexity indicates that the task complexity of the subtask is not less than the preset task complexity threshold; the delay-sensitive type indicates that the task complexity of the subtask is less than the preset task complexity threshold, and the expected completion delay of the subtask is not less than the preset delay-sensitive threshold;

[0054] Modeling the decision-making process of the target subtask to obtain the optimal offloading decision of the target subtask, so that the overall benefit of the joint optimization of energy consumption and delay in processing the target subtask is maximized;

[0055] The target subtask is processed according to the optimal offloading decision, or the target subtask is offloaded to a cloud server node so that the cloud server node processes the target subtask.

[0056] Optionally, modeling the decision process of the target subtask to obtain the optimal offloading decision of the target subtask includes:

[0057] A semi-Markov process (SMDP) is used to model the target subtask offloading process;

[0058] A reference reward model is used to evaluate uninstall behavior;

[0059] An iterative algorithm is used to maximize the long-term reward of the SMDP modeling process, obtain the maximum benefit of the system, and obtain the optimal offloading decision of the target subtask.

[0060] Optionally, a semi-Markov process (SMDP) is used to perform decision modeling on the target subtask offloading process, including:

[0061] Based on the arrival and departure of the terminal node at the service coverage node, the state space and behavior space of the target task arriving at or leaving the waiting queue are modeled:

[0062] The state space e is modeled as:

[0063] e∈E={A R ,D R}

[0064] Among them, A R Indicates that the target subtask that requires R computing units arrives in the queue, D R Indicates that the target subtask requiring R computing units is completed and leaves the queue;

[0065] Corresponding to the state space e, MEC generates a state set S that allocates the corresponding number of computing units:

[0066] S={s|s=(R1,R2,...,R m ,M,e)}

[0067] Where M represents the maximum number of computing units that can be allocated to a single MEC; the state set S represents the number of computing units allocated to the target subtask. When s=R0, the target subtask enters the waiting queue. When the target subtask source in the waiting queue leaves the node service range, the target subtask is abandoned.

[0068] Under different event states, the decision behavior space a(s) of the MEC edge computing server allocating a certain number of available computing units to the target subtask is modeled:

[0069] a(s)={-1,0,1,2,...,N}

[0070] Among them, a(s)=-1 means that the service node is fully serviced, and the target subtask is completed and returned to the terminal node; a(s)=0 means that the node rejects the user's request to offload the task and abandons the target subtask when the user leaves; a(s)=i means that the service node allocates i computing units to process the subtask according to the waiting queue.

[0071] Optionally, a reference reward model is used to evaluate uninstall behavior, including:

[0072] Calculate the income k(s,a):

[0073]

[0074] Where k(s,a) represents the benefit of taking action a in state s, which comes from saving energy for the task offloading model and shortening the task processing delay; i represents the number of allocated computing units; E represents the maximum energy consumed when processing the subtask, which is obtained from the historical maximum processor consumption uploaded; T represents the time it takes for the subtask to start from the terminal and return; D p (i) represents the delay consumption caused by link transmission; α and β represent the performance factors for energy saving and delay saving respectively; η represents the penalty factor for a task arriving but still being assigned to the waiting queue; θ represents the penalty factor for a task that is no longer in the service node and there are still tasks waiting to be processed in the waiting queue and there are idle service units; μ represents the computational efficiency of the computing unit; p represents the probability of offloading to the edge server node, and δ represents the energy consumed by the edge server node;

[0075] Calculate the expected cost g(s,a):

[0076] g(s,a)=c(s,a)τ(s,a)

[0077] Where g(s,a) represents the expected cost of the system during the state transition of taking action a in state s; c(s,a) represents the resource cost of node allocation, which comes from the consumption generated by communication and is given by the developer based on the amount of task data; τ(s,a) represents the probability of the occurrence of a duration event of state transition, assuming that the duration follows an exponential distribution;

[0078] Calculate the uninstall behavior reward r(s,a):

[0079] r(s,a)=k(s,a)-g(s,a)

[0080] Among them, r(s,a) is the reward obtained by uninstalling the behavior when taking action a in state s.

[0081] Optionally, an iterative algorithm is used to maximize the long-term reward of the SMDP modeling process, obtain the maximum benefit of the system, and obtain the optimal offloading decision of the target subtask, including:

[0082] In each iteration, the maximum value function of each state under different effects is iteratively calculated according to the Bellman equation:

[0083]

[0084] Where v(s) represents the maximum benefit of transferring from state s' to the current state s; v(s') is the initialization value function in the previous iteration; λ is the probability of task transfer; g(s,a) is the cost; p(s'|s,a) is the probability of transferring from state s' to state s when task transfer occurs;

[0085] Repeat the iteration until the maximum value function of each state converges, set the number of iterations to zero, and initialize the value function of each state to zero;

[0086] Compute normalized costs and transition probabilities:

[0087]

[0088]

[0089] The cost is normalized to The transition probability is normalized to y = Kλ + KRμ; σ(s,a) represents the probability of task occurrence;

[0090] Combining the above two formulas, calculate the maximum gain after normalization

[0091]

[0092] According to the equation Calculate the maximum value of the normalization of each state, and after reaching the expected maximum number of iterations k, calculate the absolute difference Δ between the last few iteration states:

[0093]

[0094] ξ is a preset value. When Δ≤ξ, the solution is the optimal solution. The state set in the optimal solution is the optimal state set, and the optimal offloading decision of the target subtask is obtained; the optimal offloading decision determines the node that processes the target task.

[0095] An embodiment of the present invention provides a task offloading method for an intelligent edge computing system with multi-user access, which is applied to a terminal node, obtains the original task collected by the sensor connected to the terminal node, and determines whether the original task meets the local offloading condition; if the original task meets the local offloading condition, the original task is divided and sorted and integrated into a linear task queue containing multiple subtasks; the task type of each subtask is determined based on the task complexity and expected completion delay of the subtask; the task types include delay-sensitive type, computational complexity and terminal task type; the terminal task type indicates that the task complexity of the subtask is less than a preset task complexity threshold, and the expected completion delay of the subtask is less than the preset delay-sensitive threshold; the computational complexity type indicates that the task complexity of the subtask is not less than the preset task complexity threshold value; delay-sensitive type means that the task complexity of the subtask is less than the preset task complexity threshold, and the expected completion delay of the subtask is not less than the preset delay-sensitive threshold; for each subtask, if the subtask is a terminal task type, the subtask is processed; if the subtask is computationally complex, the subtask is unloaded to the cloud server node so that the cloud server node processes the subtask; if the subtask is delay-sensitive type, the subtask is unloaded to the edge server node so that the edge server node models the decision-making process of the subtask to obtain the optimal offloading decision of the subtask, so that the overall benefit of the joint optimization of energy consumption and delay in processing the target subtask is maximized, the subtask is processed, or the subtask is unloaded to the cloud server node so that the cloud server node processes the subtask.

[0096] By classifying the tasks obtained by the terminal nodes into delay-sensitive, computationally complex, and terminal task types, the problem of node computing resource mismatch caused by unclear business types during computing offloading is optimized, and the overall processing efficiency of the edge computing system is improved; and the original tasks are divided into sub-tasks that can be executed independently, so that the divided tasks can be more flexibly offloaded to different nodes, effectively reducing the computing and waiting delays caused by excessive task volume, and reducing the coupling between task completions; the edge server node models the task offloading process, and reasonably judges the task offloading decision and offloading location based on the historical processing data of the task calculation, effectively shortening the computing delay caused by the long task processing waiting queue, and meeting the requirement of minimizing energy loss as much as possible within the delay constraint. BRIEF DESCRIPTION OF THE DRAWINGS

[0097] The present invention will be further described below with reference to the accompanying drawings.

[0098] Figure 1 A task offloading method for a multi-user access intelligent edge computing system applied to a terminal node provided in an embodiment of the present invention;

[0099] Figure 2A task offloading method for a multi-user access intelligent edge computing system applied to an edge server node provided in an embodiment of the present invention;

[0100] Figure 3 This is a system block diagram of the multi-user access intelligent edge computing system used in an embodiment of the present invention. DETAILED DESCRIPTION

[0101] The following will clearly and completely describe the technical solutions in the embodiments of the present invention in conjunction with the accompanying drawings. Obviously, the described embodiments are only part of the embodiments of the present invention, not all of the embodiments. Based on the embodiments of the present invention, all other embodiments obtained by ordinary technicians in this field without making any creative efforts shall fall within the scope of protection of the present invention.

[0102] The embodiment of the present invention provides a task offloading method for a multi-user access intelligent edge computing system, which is applied to a terminal node. Figure 1 , Figure 1 A task offloading method for a multi-user access intelligent edge computing system applied to a terminal node provided in an embodiment of the present invention may include the following steps:

[0103] S101: Obtain data collected by sensors connected to terminal nodes to generate original tasks to be calculated, and determine whether the original tasks meet local offloading conditions.

[0104] S102: If the original task meets the local offloading condition, the original task is split and sorted into a linear task queue containing multiple subtasks.

[0105] S103: Determine the task type of each subtask based on the task complexity and expected completion delay of the subtask.

[0106] S104, for each subtask, if the subtask is a terminal task type, process the subtask;

[0107] S105, for each subtask, if the subtask is computationally complex, offloading the subtask to a cloud server node so that the cloud server node processes the subtask;

[0108] S106, for each subtask, if the subtask is delay-sensitive, the subtask is unloaded to the edge server node, so that the edge server node models the decision-making process of the subtask to obtain the optimal unloading decision of the subtask, so that the overall benefit of the joint optimization of energy consumption and delay in processing the subtask is maximized, and the subtask is processed, or the subtask is unloaded to the cloud server node so that the cloud server node processes the subtask.

[0109] The task types include delay-sensitive, computationally complex, and terminal task types; the terminal task type indicates that the task complexity of the subtask is less than a preset task complexity threshold, and the expected completion delay of the subtask is less than a preset delay-sensitive threshold; the computationally complex type indicates that the task complexity of the subtask is not less than a preset task complexity threshold; the delay-sensitive type indicates that the task complexity of the subtask is less than a preset task complexity threshold, and the expected completion delay of the subtask is not less than a preset delay-sensitive threshold;

[0110] A task offloading method for a multi-user access intelligent edge computing system provided by an embodiment of the present invention divides the tasks obtained by the terminal nodes into delay-sensitive, computationally complex and terminal task types, thereby optimizing the problem of node computing resource mismatch caused by unclear business types during the computation offloading process and improving the overall processing efficiency of the edge computing system; and dividing the original tasks into independently executable sub-tasks, so that the divided tasks can be more flexibly offloaded to different nodes, effectively reducing the calculation and waiting delays caused by excessive task volume and reducing the coupling between task completions; the edge server node models the task offloading process, and reasonably judges the task offloading decision and offloading location based on the historical processing data of the task calculation, effectively shortening the computational delay caused by the long task processing waiting queue, and meeting the requirement of minimizing energy loss as much as possible within the delay constraint.

[0111] In one implementation, terminal nodes can be connected to a variety of sensors, which are connected to the terminal device through software and hardware protocols. Sensors, PLC programmable logic controllers, or single-chip microcomputer modules are connected to the terminal device through software and hardware protocols such as MQTT, Modbus, and OPC-UA.

[0112] In one implementation, the edge server node models the offloading decision process to solve the problem of multiple users competing for computing resources and offloads subtasks with poor resource competition capabilities to the cloud server node.

[0113] In one implementation, the cloud server node stores the relevant data of processing the subtask in the database, and calculates indicators such as disk usage, latency savings, and CPU usage generated by the subtask calculation.

[0114] In one embodiment, before step S102, the method further includes:

[0115] Step 1: Calculate the actual start time AST(j) of the original task:

[0116] AST(j)=max{avail{0∪[k]},max(AFT(j')+C jj' )} (1)

[0117] Where avail{0∪[k]} represents the earliest ready execution time of the terminal node or cloud server node k, j' represents the predecessor tasks of all the original tasks, C jj' Indicates the scheduling time of j' and j task results.

[0118] Step 2: The actual end time of the predecessor task j' is AFT(j'):

[0119] AFT(j')=min{D p (j')+AST(j')} (2)

[0120] Among them, D p (j') is the execution time of the predecessor task.

[0121] Step 3: Iterate the end time of the current task from the results of all associated predecessor tasks, and calculate the actual completion time AFT of the original task on the cloud server node sever (j) and the actual completion time AFT at the terminal node local (j).

[0122] Step 4: Determine whether the original task meets the local offloading conditions. If AFT sever (j)≤AFT local (j) If the original task does not meet the local offloading condition, the original task is offloaded to the cloud server node so that the cloud server node processes the original task. Otherwise, the original task meets the local offloading condition.

[0123] In one embodiment, step S103 includes:

[0124] Step 1: Topologically split the original task as a whole according to the inheritance and parallelism of the task;

[0125] Step 2: Find the target task that minimizes the original task completion time:

[0126]

[0127] Among them, a(s) represents the action taken in state s, and N is the total number of system tasks.

[0128] Step 3: Select the task with the shortest processing time as the first task to be executed in the priority queue. When the tasks are divided and arranged into a linear queue, the priority of the subsequent task must be lower than that of the predecessor task.

[0129] Step 4: Design a subtask priority sorting algorithm to integrate the subtasks into a linear queue of pending tasks:

[0130] Calculate the priority of subtask j:

[0131] Rank(j)=D t (j)+max(R m +Rank(j')) (4)

[0132] Among them, D t (j) is the processing time of subtask j, R m is the processing time of all predecessor tasks, and Rank(j') is the processing time of the predecessor tasks that have an inheritance relationship with subtask j.

[0133] Step 5: Sort all subtasks in descending order of priority to obtain a linear task queue.

[0134] The inheritance of tasks means that the execution of subsequent tasks depends on the completion of predecessor tasks; the parallelism of tasks means that there is no logical dependency between the execution of two tasks.

[0135] In one implementation, even if one of the two parallel tasks is not executed, it will not affect the execution of the other task.

[0136] In one implementation, the subtask priority sorting algorithm divides the overall task into subtasks that can be executed independently, and prioritizes the divided tasks based on the two factors of parallelism and inheritance, so that the divided tasks can be more flexibly offloaded to different nodes, effectively reducing the calculation and waiting delays caused by excessive task volume, and reducing the coupling between task completion.

[0137] In one embodiment, the edge server nodes and terminal nodes are collectively referred to as the edge side;

[0138] Step S103 may include the following steps:

[0139] Step 1: Based on the computing resources and computing power of the edge side and the execution of tasks of different complexity, determine the upper limit of the comprehensive complexity that the edge side can withstand as α max .

[0140] Step 2: According to the time and algorithm complexity of each subtask, determine the comprehensive complexity of task i as α i .

[0141] Step 3: Determine the delay threshold t of each subtask according to the delay constraint requirements of the subtask max .

[0142] Step 4: Calculate the completion time t of each subtask ij .

[0143] Step 5: According to α max , α i , t maxand t ij The relationship between them determines the task type of the subtask.

[0144] In one implementation, if the subtasks simultaneously satisfy α i ≤α max And t ij ≤t max , then the subtask is determined to be a terminal task type and is processed directly at the terminal node; if α i >α max , then the subtask is a computationally complex task and is offloaded to the cloud computing center; if α i ≤α max And t ij >t max In the case of , the task is a delay-sensitive task and is offloaded to the edge server node.

[0145] In one embodiment, the completion time t of each subtask is calculated ij Specifically include:

[0146] Step 1: Calculate the channel transmission power:

[0147]

[0148] Among them, g ij represents the channel gain from terminal node i to cloud server node j, B is the bandwidth, N0 is the white noise power, and p is the transmit power;

[0149] Step 2: Split the completion time of each subtask into transmission time and calculation time

[0150] Calculate the transmission time of this subtask

[0151]

[0152] Among them, m i Indicates the total amount of data that needs to be transferred;

[0153] Step 3: Calculate the computing time of the task

[0154]

[0155] Among them, c i Indicates the number of CPU cycles required to process each subtask, f ij Indicates the computing resources allocated by the server to this subtask,

[0156] Step 4: Calculate the total task completion time:

[0157]

[0158] Based on the same inventive concept, the embodiment of the present invention also provides a task offloading method for a multi-user access intelligent edge computing system, which is applied to an edge server node. Figure 2 , Figure 2 A task offloading method for a multi-user access intelligent edge computing system provided by an embodiment of the present invention and applied to an edge server node may include the following steps:

[0159] S201, receiving a target subtask sent by a terminal node.

[0160] S202 , modeling the decision-making process of the target subtask to obtain the optimal offloading decision of the target subtask, so as to maximize the overall benefit of the joint optimization of energy consumption and delay in processing the target subtask.

[0161] S203: Process the target subtask according to the optimal offloading decision, or offload the target subtask to the cloud server node so that the cloud server node processes the target subtask.

[0162] The target subtask is a delay-sensitive subtask in the linear task queue of the terminal node, determined according to the task complexity and expected completion delay of each subtask; the linear task queue of the terminal node is a task queue containing multiple subtasks obtained by splitting and sorting the original task that meets the local offloading conditions at the terminal node; the original task is a task collected by the sensor connected to the terminal node; the task types include delay-sensitive, computational complexity and terminal task; the terminal task type indicates that the task complexity of the subtask is less than the preset task complexity threshold, and the expected completion delay of the subtask is less than the preset delay-sensitive threshold; the computational complexity type indicates that the task complexity of the subtask is not less than the preset task complexity threshold; the delay-sensitive type indicates that the task complexity of the subtask is less than the preset task complexity threshold, and the expected completion delay of the subtask is not less than the preset delay-sensitive threshold.

[0163] A task offloading method for a multi-user access intelligent edge computing system provided by an embodiment of the present invention divides the tasks obtained by the terminal nodes into delay-sensitive, computationally complex and terminal task types, thereby optimizing the problem of node computing resource mismatch caused by unclear business types during the computation offloading process and improving the overall processing efficiency of the edge computing system; and dividing the original tasks into independently executable sub-tasks, so that the divided tasks can be more flexibly offloaded to different nodes, effectively reducing the calculation and waiting delays caused by excessive task volume and reducing the coupling between task completions; the edge server node models the task offloading process, and reasonably judges the task offloading decision and offloading location based on the historical processing data of the task calculation, effectively shortening the computational delay caused by the long task processing waiting queue, and meeting the requirement of minimizing energy loss as much as possible within the delay constraint.

[0164] In one implementation, the edge server node models the offloading decision process to solve the problem of multiple users competing for computing resources and offloads subtasks with poor resource competition capabilities to the cloud server node.

[0165] In one implementation, the operation steps of the terminal node may refer to the introduction of S101 to S104 above.

[0166] In one embodiment, the decision-making process modeling of the target subtask in step S202 to obtain the optimal offloading decision of the target subtask specifically includes:

[0167] Step 1: Use the semi-Markov process SMDP to model the decision-making process of the target subtask offloading process.

[0168] Step 2: Use the reference reward model to evaluate the uninstall behavior.

[0169] Step 3: Use an iterative algorithm to maximize the long-term reward of the SMDP modeling process, obtain the maximum benefit of the system, and obtain the optimal offloading decision of the target subtask.

[0170] In one embodiment, a semi-Markov process (SMDP) is used to model the target subtask offloading process, specifically including:

[0171] Step 1: Based on the arrival and departure of the terminal node at the service coverage node, the state space and behavior space of the target task arriving at or leaving the waiting queue are modeled:

[0172] The state space e is modeled as:

[0173] e∈E={A R ,D R} (9)

[0174] Among them, A RIndicates that the target subtask that requires R computing units arrives in the queue, D R It indicates that the target subtask requiring R computing units is processed and leaves the queue.

[0175] Step 2: For the state space e, MEC generates a state set S that allocates the corresponding number of computing units:

[0176] S={s|s=(R1,R2,...,R m ,M,e)} (10)

[0177] Among them, M represents the maximum number of computing units that can be allocated to a single MEC; the state set S represents the computing units with the corresponding subscript number allocated to the target subtask. When s=R0, the target subtask enters the waiting queue. When the source of the target subtask in the waiting queue leaves the service range of the node, the target subtask is abandoned.

[0178] Step 3: Model the decision behavior space a(s) of the MEC edge computing server allocating a certain number of available computing units to the target subtask under different event states:

[0179] a(s)={-1,0,1,2,...,N} (11)

[0180] Among them, a(s)=-1 means that the service node is fully serviced, and the target subtask is completed and returned to the terminal node; a(s)=0 means that the node rejects the user's request to offload the task and abandons the target subtask when the user leaves; a(s)=i means that the service node allocates i computing units to process the subtask according to the waiting queue.

[0181] In one embodiment, a reference reward model is used to evaluate uninstall behavior, specifically including:

[0182] Step 1: Calculate income k(s,a):

[0183]

[0184] Where k(s,a) represents the benefit of taking action a in state s, which comes from saving energy for the task offloading model and shortening the task processing delay; i represents the number of allocated computing units; E represents the maximum energy consumed when processing the subtask, which is obtained from the historical maximum processor consumption uploaded; T represents the time it takes for the subtask to start from the terminal and return; D p(i) represents the delay consumption caused by link transmission; α and β represent the performance factors for energy saving and delay saving respectively; η represents the penalty factor for tasks arriving but still being assigned to the waiting queue; θ represents the penalty factor for tasks that are no longer in the service node and there are still tasks waiting to be processed in the waiting queue and there are idle service units; μ represents the computational efficiency of the computing unit; p represents the probability of offloading to the edge server node, and δ represents the energy consumed by the edge server node;

[0185] Step 2: Calculate the expected cost g(s,a):

[0186] g(s,a)=c(s,a)τ(s,a) (13)

[0187] Where g(s,a) represents the expected cost of the system during the state transition of taking action a in state s; c(s,a) represents the resource cost of node allocation, which comes from the consumption generated by communication and is given by the developer based on the amount of task data; τ(s,a) represents the probability of the occurrence of a duration event of state transition, assuming that the duration follows an exponential distribution;

[0188] Step 3: Calculate the uninstall behavior reward r(s,a):

[0189] r(s,a)=k(s,a)-g(s,a) (14)

[0190] Among them, r(s,a) is the reward obtained by uninstalling the behavior when taking action a in state s.

[0191] In one embodiment, an iterative algorithm is used to maximize the long-term return of the SMDP modeling process, obtain the maximum benefit of the system, and obtain the optimal offloading decision of the target subtask, specifically including:

[0192] Step 1: In each iteration, the maximum value function of each state under different effects is iteratively calculated according to the Bellman equation:

[0193]

[0194] Where v(s) represents the maximum benefit of transferring from state s' to the current state s; v(s') is the initialization value function in the previous iteration; λ is the probability of task transfer; g(s,a) is the cost; and p(s'|s,a) is the probability of transferring from state s' to state s when task transfer occurs.

[0195] Step 2: Repeat the iteration until the maximum value function of each state converges, set the number of iterations to zero, and initialize the value function of each state to zero.

[0196] Step 3: Calculate the normalized cost and transition probability:

[0197]

[0198]

[0199] The cost is normalized to The transition probability is normalized to y = Kλ + KRμ; σ(s,a) represents the probability of task occurrence;

[0200] Step 4: Combine the above two equations (16) and (17) to calculate the maximum gain after normalization

[0201]

[0202] Step 5: According to the equation Calculate the maximum value of the normalization of each state, and after reaching the expected maximum number of iterations k, calculate the absolute difference Δ between the last few iteration states:

[0203]

[0204] ξ is a preset value. When Δ≤ξ, the solution is the best solution. The state set in the best solution is the optimal state set, and the optimal offloading decision of the target subtask is obtained. The optimal offloading decision determines the node that processes the target task.

[0205] Reference Figure 3 , Figure 3 This is a block diagram of the multi-user intelligent edge computing system used in an embodiment of the present invention. The system adopts a three-layer structure: the terminal device layer (terminal nodes), the edge device layer (edge computing nodes), and the cloud computing center layer (cloud computing nodes).

[0206] The terminal device layer primarily consists of sensors and mobile devices. These are widely distributed and numerous, generating large amounts of raw data. They can be a complete IoT sensor device, a single chip, or a networked camera. The edge device layer consists of gateways with lower computing power and edge gateways with higher computing power. The cloud server consists of cloud nodes (full nodes), data centers, and visual operations and maintenance.

[0207] The edge device layer deploys multiple terminal nodes that access the system. These modules are primarily divided into data collection, data preprocessing, task segmentation, and communication modules. These modules aggregate sensor and other terminal data and communicate with servers. The edge device layer includes modules for data storage, data processing, decision-making relay, and communication. These modules possess computing and storage capabilities, enabling them to perform tasks that are difficult to perform at the terminal and have strict latency requirements. The cloud computing center layer primarily includes communication modules, data processing, task metric calculation, and data storage. This layer primarily handles tasks that are more challenging to complete but have relatively relaxed latency requirements.

[0208] The above is a detailed description of an embodiment of the present invention. However, the content described is only a preferred embodiment of the present invention and should not be considered to limit the scope of the present invention. All equivalent changes and improvements made within the scope of the present invention should still fall within the scope of the patent coverage of the present invention.

Claims

1. A task offloading method for a multi-user access intelligent edge computing system, characterized in that: Applied to a terminal node, the method includes: Obtaining data collected by sensors connected to the terminal node to generate an original task to be calculated, and determining whether the original task meets a local offloading condition; If the original task meets the local offloading condition, the original task is split and sorted into a linear task queue containing multiple subtasks; The task type of each subtask is determined based on its task complexity and expected completion delay; the task types include delay-sensitive type, computational complexity type, and terminal task type; the terminal task type indicates that the task complexity of the subtask is less than a preset task complexity threshold, and the expected completion delay of the subtask is less than a preset delay-sensitive threshold; the computational complexity type indicates that the task complexity of the subtask is not less than a preset task complexity threshold; the delay-sensitive type indicates that the task complexity of the subtask is less than a preset task complexity threshold, and the expected completion delay of the subtask is not less than a preset delay-sensitive threshold; For each subtask, if the subtask is of the terminal task type, the subtask is processed; if the subtask is of the computationally complex type, the subtask is offloaded to the cloud server node so that the cloud server node processes the subtask; if the subtask is of the delay-sensitive type, the subtask is offloaded to the edge server node so that the edge server node models the decision process of the subtask to obtain the optimal offloading decision for the subtask, so that the overall benefit of the joint optimization of energy consumption and delay in processing the subtask is maximized, and the subtask is processed, or the subtask is offloaded to the cloud server node so that the cloud server node processes the subtask; The decision-making process of this subtask is modeled to obtain the optimal offloading decision for this subtask, including: The semi-Markov process SMDP is used to model the decision-making of the subtask offloading process; A reference reward model is used to evaluate uninstall behavior; The iterative algorithm is used to maximize the long-term return of the SMDP modeling process, obtain the maximum benefit of the system, and obtain the optimal offloading decision for the subtask; A reference reward model is used to evaluate uninstall behavior, including: Calculate the income k(s,a): Where k(s,a) represents the benefit of taking action a in state s, which comes from saving energy for the task offloading model and shortening the task processing delay; i represents the number of allocated computing units; E represents the maximum energy consumed when processing the subtask, which is obtained from the historical maximum processor consumption uploaded; T represents the time it takes for the subtask to start from the terminal and return; D p (i) represents the delay consumption caused by link transmission; α and β represent the performance factors for energy saving and delay saving respectively; η represents the penalty factor for a task arriving but still being assigned to the waiting queue; θ represents the penalty factor for a task that is no longer in the service node and there are still tasks waiting to be processed in the waiting queue and there are idle service units; μ represents the computational efficiency of the computing unit; p represents the probability of offloading to the edge server node, and δ represents the energy consumed by the edge server node; Calculate the expected cost g(s,a): g(s,a)=c(s,a)τ(s,a) Where g(s,a) represents the expected cost of the system during the state transition of taking action a in state s; c(s,a) represents the resource cost of node allocation, which comes from the consumption generated by communication and is given by the developer based on the amount of task data; τ(s,a) represents the probability of the occurrence of a duration event of state transition, assuming that the duration follows an exponential distribution; Calculate the uninstall behavior reward r(s,a): r(s,a)=k(s,a)-g(s,a) Among them, r(s,a) is the reward obtained by uninstalling the behavior when taking action a in state s.

2. The task offloading method of a multi-user access intelligent edge computing system according to claim 1, characterized in that: Before dividing and sorting the original task into a linear task queue containing a plurality of subtasks, the method further includes: Calculate the actual start time AST(j) of the original task: AST(j)=max{avail{0∪[k]},max(AFT(j')+C jj' )} Wherein, avail{0∪[k]} represents the earliest ready execution time of the terminal node or the cloud server node k, j' represents the predecessor tasks of all the original tasks, C jj' represents the scheduling time of task j' and task j' results; The actual end time of predecessor task j' is AFT(j'): AFT(j')=min{D p (j')+AST(j')} Among them, D p (j') is the execution time of the predecessor task; Iterate the current task end time from all associated predecessor task results, and calculate the actual completion time AFT of the original task on the cloud server node respectively. sever (j) and the actual completion time AFT at the terminal node local (j); Determine whether the original task meets the local offloading conditions. If AFT sever (j)≤AFT local (j) If the original task does not meet the local offloading condition, the original task is offloaded to the cloud server node so that the cloud server node processes the original task; otherwise, the original task meets the local offloading condition.

3. The task offloading method of a multi-user access intelligent edge computing system according to claim 1, characterized in that: If the original task meets the local offloading condition, the original task is divided and sorted into a linear task queue containing multiple subtasks. The method includes: The original task as a whole is topologically divided according to the inheritance and parallelism of the tasks; the inheritance of the tasks means that the execution of the subsequent tasks depends on the completion of the predecessor tasks; the parallelism of the tasks means that there is no logical dependency between the execution of the two tasks; Solve the target task that minimizes the completion time of the original task: Where a(s) represents the action taken in state s, and N is the total number of system tasks; The task with the shortest processing time is selected as the first task to be executed in the priority queue. When the tasks are divided and arranged into a linear queue, the priority of the subsequent tasks must be lower than that of the predecessor tasks. Design a subtask priority sorting algorithm to integrate subtasks into a linear queue of pending tasks: Calculate the priority of subtask j: Rank(j)=D t (j)+max(R m +Rank(j')) Among them, D t (j) is the processing time of subtask j, R m is the processing time of all predecessor tasks, Rank(j') is the processing time of the predecessor tasks that have an inheritance relationship with subtask j; Sort all subtasks in descending order of priority to obtain a linear task queue.

4. The task offloading method of a multi-user access intelligent edge computing system according to claim 1, characterized in that: The edge server node and the terminal node are collectively referred to as the edge side; Determine the task type of each subtask based on its complexity and expected completion delay, including: According to the computing resources and computing power of the edge side, combined with the execution of tasks of different complexity, the upper limit of the comprehensive complexity that the edge side can withstand is determined as α max ; According to the time and algorithm complexity of each subtask, the comprehensive complexity of task i is determined to be α i ; According to the delay constraint requirements of each subtask, determine the delay threshold t of the subtask max ; Calculate the completion time t of each subtask ij ; According to α max , α i , t max and t ij The relationship between them determines the task type of the subtask.

5. The method for offloading tasks in a multi-user access intelligent edge computing system according to claim 4, characterized in that: Calculate the completion time t of each subtask ij ,include: Calculate the channel transmission power: Among them, g ij represents the channel gain from the terminal node i to the cloud server node j, B is the bandwidth, N0 is the white noise power, and p is the transmit power; Split the completion time of each subtask into transmission time and calculation time Calculate the transmission time of this subtask Among them, m i Indicates the total amount of data that needs to be transferred; Calculate the computation time of the task Among them, c i Indicates the number of CPU cycles required to process each subtask, f ij Indicates the computing resources allocated by the server to this subtask, Calculate the total task completion time:

6. A task offloading method for a multi-user access intelligent edge computing system, characterized in that: Applied to an edge server node, the method includes: Receive a target subtask sent by a terminal node; the target subtask is a delay-sensitive subtask in the linear task queue of the terminal node, whose task type is determined according to the task complexity and expected completion delay of each subtask; the linear task queue of the terminal node is a task queue containing multiple subtasks obtained by the terminal node by splitting and sorting and integrating the original task that meets the local unloading conditions; the original task is a task collected by the sensor connected to the terminal node; the task types include delay-sensitive, computational complexity and terminal task types; the terminal task type indicates that the task complexity of the subtask is less than a preset task complexity threshold, and the expected completion delay of the subtask is less than the preset delay-sensitive threshold; the computational complexity indicates that the task complexity of the subtask is not less than the preset task complexity threshold; the delay-sensitive type indicates that the task complexity of the subtask is less than the preset task complexity threshold, and the expected completion delay of the subtask is not less than the preset delay-sensitive threshold; Modeling the decision-making process of the target subtask to obtain the optimal offloading decision of the target subtask, so that the overall benefit of the joint optimization of energy consumption and delay in processing the target subtask is maximized; Processing the target subtask according to the optimal offloading decision, or offloading the target subtask to a cloud server node so that the cloud server node processes the target subtask; Modeling the decision process of the target subtask to obtain the optimal offloading decision of the target subtask includes: A semi-Markov process (SMDP) is used to model the target subtask offloading process; A reference reward model is used to evaluate uninstall behavior; An iterative algorithm is used to maximize the long-term return of the SMDP modeling process, obtain the maximum benefit of the system, and obtain the optimal offloading decision of the target subtask; A reference reward model is used to evaluate uninstall behavior, including: Calculate the income k(s,a): Where k(s,a) represents the benefit of taking action a in state s, which comes from saving energy for the task offloading model and shortening the task processing delay; i represents the number of allocated computing units; E represents the maximum energy consumed when processing the subtask, which is obtained from the historical maximum processor consumption uploaded; T represents the time it takes for the subtask to start from the terminal and return; D p (i) represents the delay consumption caused by link transmission; α and β represent the performance factors for energy saving and delay saving respectively; η represents the penalty factor for a task arriving but still being assigned to the waiting queue; θ represents the penalty factor for a task that is no longer in the service node and there are still tasks waiting to be processed in the waiting queue and there are idle service units; μ represents the computational efficiency of the computing unit; p represents the probability of offloading to the edge server node, and δ represents the energy consumed by the edge server node; Calculate the expected cost g(s,a): g(s,a)=c(s,a)τ(s,a) Where g(s,a) represents the expected cost of the system during the state transition of taking action a in state s; c(s,a) represents the resource cost of node allocation, which comes from the consumption generated by communication and is given by the developer based on the amount of task data; τ(s,a) represents the probability of the occurrence of a duration event of state transition, assuming that the duration follows an exponential distribution; Calculate the uninstall behavior reward r(s,a): r(s,a)=k(s,a)-g(s,a) Among them, r(s,a) is the reward obtained by uninstalling the behavior when taking action a in state s.

7. The method for offloading tasks in a multi-user access intelligent edge computing system according to claim 6, characterized in that: The semi-Markov process SMDP is used to perform decision modeling on the target subtask offloading process, including: According to the arrival and departure of the terminal node at the service coverage node, the state space and behavior space of the target subtask arriving at or leaving the waiting queue are modeled: The state space e is modeled as: e∈E={A R ,D R } Among them, A R Indicates that the target subtask that requires R computing units arrives in the queue, D R Indicates that the target subtask requiring R computing units is completed and leaves the queue; Corresponding to the state space e, MEC generates a state set S that allocates the corresponding number of computing units: S={s|s=(R1,R2,...,R m ,M,e)} Where M represents the maximum number of computing units that can be allocated to a single MEC; the state set S represents the number of computing units allocated to the target subtask. When s=R0, the target subtask enters the waiting queue. When the target subtask source in the waiting queue leaves the node service range, the target subtask is abandoned. Under different event states, the decision behavior space a(s) of the MEC edge computing server allocating a certain number of available computing units to the target subtask is modeled: a(s)={-1,0,1,2,...,N} Among them, a(s)=-1 means that the service node is fully serviced, and the target subtask is completed and returned to the terminal node; a(s)=0 means that the node rejects the user's request to offload the task and abandons the target subtask when the user leaves; a(s)=i means that the service node allocates i computing units to process the subtask according to the waiting queue.

8. The method for offloading tasks in a multi-user access intelligent edge computing system according to claim 6, characterized in that: An iterative algorithm is used to maximize the long-term return of the SMDP modeling process, obtain the maximum benefit of the system, and obtain the optimal offloading decision of the target subtask, including: In each iteration, the maximum value function of each state under different effects is iteratively calculated according to the Bellman equation: Where v(s) represents the maximum benefit of transferring from state s' to the current state s; v(s') is the initialization value function in the previous iteration; λ is the probability of task transfer; g(s,a) is the cost; p(s'|s,a) is the probability of transferring from state s' to state s when task transfer occurs; Repeat the iteration until the maximum value function of each state converges, set the number of iterations to zero, and initialize the value function of each state to zero; Compute normalized costs and transition probabilities: The cost is normalized to The transition probability is normalized to y = Kλ + KRμ; σ(s,a) represents the probability of task occurrence; Combining the above two formulas, calculate the maximum gain after normalization According to the equation Calculate the maximum value of the normalization of each state, and after reaching the expected maximum number of iterations k, calculate the absolute difference Δ between the last few iteration states: ξ is a preset value. When Δ≤ξ, the decision is the best solution. The state set in the best solution is the optimal state set, and the optimal offloading decision of the target subtask is obtained; the optimal offloading decision determines the node that processes the target subtask.

Images