{'fraction_non_alphanumeric': 0.025305076316896827, 'fraction_numerical': 0.007057878428522245, 'mean_word_length': 4.708997597728762, 'pattern_counts': {'":': 0, '<': 4, '<?xml version=': 0, '>': 1, 'https://': 0, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 4, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
Joint Optimization of Sensing and Computation for Status Update in Mobile Edge Computing Systems

IoT devices recently are utilized to detect the state transition in the surrounding environment and then transmit the status updates to the base station for future system operations. To satisfy the stringent timeliness requirement of the status updates for the accurate system control, age of information (AoI) is introduced to quantify the freshness of the sensory data. Due to the limited computing resources, the status update can be offloaded to the mobile edge computing (MEC) server for execution to ensure the information freshness. Since the status updates generated by insufficient sensing operations may be invalid and cause additional processing time, the data sensing and processing operations need to be considered simultaneously. In this work, we formulate the joint data sensing and processing optimization problem to ensure the freshness of the status updates and reduce the energy consumption of IoT devices. Then, the formulated NP-hard problem is decomposed into the sampling, sensing and computation offloading optimization problems. Afterwards, we propose a multi-variable iterative system cost minimization algorithm to optimize the system overhead. Simulation results show the efficiency of our method in decreasing the system cost and dominance of sensing and processing under different scenarios.


A. Background and Motivation
With the development of Internet of Things (IoT) Infrastructure, ubiquitous connection of billions of IoT devices ranging from tiny IoT sensors to the more powerful smarts phones is enabled to be realistic [1]. To emerge the various IoT applications like object recognition, traffic monitoring and autonomous driving, vast information from the physical world should be extracted and transformed into status updates to realize the intelligent control for IoT devices [2]. Considering the processing operations of the status update are commonly time-consuming and computation-intensive, it is a tough task to process the sensory data in a timely manner for IoT devices with limited storage and computation capacity. Mobile edge computing (MEC) has been regarded as a promising technology to overcome the resource constraints of IoT devices by yielding cloud-like computing resources [3], [4]. In this case, IoT devices are able to offload the computing tasks to the nearby MEC server for further execution. Through deploying powerful computing resources in proximity to IoT devices and executing computing tasks on behalf of IoT devices, the computing and storage pressure of IoT devices can be relieved [5], [6].
Moreover, the accurate monitoring of the IoT system has a strict requirement on the freshness of the collected information. Recently, age of information (AoI) which is defined as the time elapsed since the generation of the last status update is adopted as a performance metric to quantify the freshness of generated status information [7]. When an IoT device generates and receives a status update successfully, its value of AoI is reset to 0. The AoI of the status update increases linearly with time until the next status update is successfully received. The average value of the AoI during the continuous sensing periods reflects the freshness of the sensory data [8]. By introducing the concept of AoI, the abstract information freshness problem can be transformed into a concrete mathematical optimization problem. The typical IoT system can be constructed as a three-layered structure including the sensing layer, the network layer and the application layer [9]. In the sensing layer, the IoT devices will keep sensing the state transition process and generate state updates when deemed necessary. Then, the sensory data are transmitted through the network layer for processing and future system control. By repeatedly receiving the valid status update from different IoT devices, the AoI at the BS can be reduced during the system control process [10]. To clarify our work in this paper, sensing and processing are explicitly defined in this paper as follows.
Definition 1: Sensing of the IoT device is defined as the process that the IoT device observes the environment transition and generates the status update when necessary.
Definition 2: Processing is defined as determining whether a status update is valid and extracting the information from the status update necessary to perform system control.
However, in the sensing layer, in order to ensure the information freshness on the BS side, IoT devices should perform the sampling operations and generate status updates at as high a frequency as possible. With the short sampling interval, the BS can achieve a low value of AoI due to the frequent status updates [11]. But sampling the state transition frequently brings additional energy consumption, which is not negligible for IoT devices with limited battery capacity. Moreover, successfully sensing the state updates may be a random event for IoT devices, due to the possible state tracking arXiv:2210.17025v1 [cs.NI] 31 Oct 2022 error rate [12], [13]. Longer sensing time can significantly improve the sensing successful rate, at the cost of additional time overhead and freshness of status updates. In addition, if the sensing time is insufficient, multiple sensing failures can lead to multiple unnecessary repetitions of sensing process. As the data sensing-processing procedure shown in Fig. 1, the IoT device that performs sensing operations three times will receive a longer sensing time and a short total task duration time. Nevertheless, the IoT device only performs a single sensing operation generates the invalid update unfortunately and has to execute the extra sensing-processing procedure until the sensing operation is successful. Thus, the sensing time of the IoT device should be considered to obtain the minimum time overhead.
In the processing part, since some information embedded in the sensory data requires further processing before it can be utilized for further system control, the execution time of the sensing task of the IoT device also has a significant impact on the freshness of the status update. Due to the computation capacity limitations of the IoT devices themselves, they would prefer to offload the tasks to the MEC server for execution to obtain shorter processing time. But selfish IoT devices will compete for limited computational and communication resources, which may create utility conflicts and increase the system overhead during the computation offloading decisionmaking process [14], [15].

B. Contribution
In view of these challenges mentioned above, we further analyze the joint optimization problem of sensing and processing in MEC system. By investigating the effects of sampling, sensing, and processing on system overhead independently, we seek to realize the IoT device sensing and processing trade-off in terms of the information freshness and energy consumption for IoT devices. The main contributions of the paper can be summarized as follows.
• We first introduce a MEC-assisted IoT system, where the IoT devices keep generating status update periodically. Then, the state sensing, data transmission and task processing are modeled separately and the AoI of the sensory data during the status updating process is formulated.
• We formulate a joint sensing and processing optimization problem for status updates to minimize the system overhead including the energy consumption and the information freshness. Then, the NP-hard problem is transformed into three subproblems to optimize the sampling interval, sensing time and computation offloading decision individually. • We solve the sensing and sampling subproblems with extremum principles, and solve the computation offloading decision-making problem with a game-theoretic approach. Then, a multi-variable iteration system cost optimization algorithm (MISCO) is proposed to minimize the system overhead. • We conduct the simulation experiments to prove the effectiveness of our proposed optimization algorithm. Numerical results illustrates the connection between the data sensing and processing.

C. Organization
The rest of this paper is organized as follows. In Section II, we discuss the related works. In Section III, we present the MEC-assist IoT system model and formulate the sensing, transmission and processing models during the status update process. In Section IV, we analyze the AoI in the considered system. In Section V, we propose the system overhead optimization problem and decompose the problem into sensing, sampling and processing subproblems. In Section VI, the joint sensing and processing optimization algorithm MISCO is proposed. In Section VII, we show the numerical results of the simulation experiment. Finally in Section VIII, we conclude our paper.

II. RELATED WORK
Freshness of the status update has emerged as a recent highlight in the field of network research, which leads to the increasing research interest in AoI served as the metrics to measure the freshness of information [16]- [21]. Yates et al. in [16] investigate real-time status updates generated by multiple independent sources sending to a single monitor with an AoI timeliness metric and derive the general values of AoI suitable for various multi-source service system. Kadota et al. in [18] study a single-hop wireless network where multiple nodes transmits time-sensitive information to the base station while minimizing the expected weighted total AoI of the network and satisfying the just-in-time throughput at the same time. Feng et al. in [19] design an optimal strategy for the energy harvesting sensor to generate status updates with the purpose of minimizing the long-term average AoI and satisfying the energy constraint in the different cases of whether the system has updating feedback. Zhou et al. in [20] study a timeintensive IoT monitoring system where IoT devices continuous generate and transmit the status updates with updating cost. Through simultaneously optimizing the sampling and updating process, the minimum average AoI of the destination node is derived under the upper bound of the updating cost. Chen et al. in [21] investigate the AoI-aware radio resource management problem in a Manhattan Grid vehicle-to-vehicle network to realize the optimal frequency allocation and packet scheduling decision-making.
Several relative works have been conducted in the context of the optimization of data sensing [2], [10], [22]- [24]. Peng et al. in [2] propose a joint sensing and communication scheduling framework for status update in the multi-access network to minimize the average status error. The trade-off between the data sensing and data transmission are investigated to minimize the long-term average AoI during multiple sensing cycles in [10], [22]. In [23], [24], UAV trajectory optimization problem where UAV performs the sensing tasks to collect the time-intensive data are studied to satisfy the system AoI threshold.
In addition to the issues mentioned above, the collected data should be offloaded to the MEC server for low-latency processing. Due to the resource competition among IoT devices, computation offloading optimization problem need to be considered. Computation offloading decision-making problem has been widely investigated to address the computation capacity constraint and communication interference. Gametheoretic method has been introduced to address the computation offloading decision-making problem [25]- [28]. Chen et al. in [25] first utilize the concept of the potential game to achieve the Nash equilibrium of the computation offloading game. Yang et al. in [26] propose a computation offloading game including multiple computation offloading schemes which take advantage of the available resources of the idle mobile devices.
However, most of the studies have focused on reducing processing latency and system energy consumption while performing computation offloading decision making, ignoring the role of information freshness in improving service quality. In addition, the state-sensing procedure may generate invalid state updates, resulting in extra processing time and deteriorating the service quality. Therefore, the sensing and processing operations need to be considered jointly to ensure the freshness of the status update and minimize the system overhead.

A. Network Model
We consider a typical MEC-assisted IoT system with a set N of N IoT devices and an MEC server. The IoT devices monitor a physical process like the traffic condition in the autonomous driving system. When deemed necessary, the IoT devices sample the status information and generate the status update which need to be processed further to achieve the accurate control. The status sampling process of each IoT device i is independent of each other, and takes the periodic delivery sampling policy of sensor updates which is one of the most common approaches in practice [30]. The sampling intervals of IoT devices are denoted as T = {τ 1 , τ 2 , ..., τ N }. The MEC server functions as a MEC server provider which is located in proximity to the IoT devices, and can be accessed by the IoT devices via the wireless channel. IoT devices that transmit computing tasks to the MEC server will be associated with clones at MEC server which execute computing tasks on behalf of IoT devices [29]. Considering the constraint of IoT devices' computation capability, each IoT device can choose to process the status information locally with its own processor or to offload the sensed data to the MEC server or more powerful computing resources. After extracting the required information from the raw status data, the computing results are transmitted to the BS for future system control. To keep the freshness of the status information and guarantee the accurate control, the sensing, transmission and processing process needs to be executed repeatedly. Fig. 2 shows the status offloading and processing procedure.

B. Sensing Model
In this section, we describe the data sensing process of generating status updates for IoT devices. Let t unit i be the sensing time for IoT device i to perform a whole sensing task once. The status update processing task generated by IoT device i can be represented as a tuple U i = {d i , c i }, where d i denotes the size of the sensory data generated in one sensing operation and c i denotes the necessary CPU cycles to finish the computing tasks.
To evaluate the sensing quality of IoT devices, we utilize the probabilistic sensing model proposed in [31]. When an IoT device executes a sensing task, the successful sensing possibility is denoted as where D s i is the distance between the IoT device and the status changing event and ξ is a positive parameter to evaluate the quality of IoT device detection depending on the environmental condition. Considering one single data sensing operation will not satisfy the sensing successful possibility requirement, the IoT device may repeat the sensing operation to improve the sensing successful possibility. Let S = {s 1 , s 2 , ..., s N } be the number of sensing operations executed by the IoT devices in a sensing operation. After finishing multiple sensing operations, the sensing successful possibility is denoted as To ensure the sensing quality, the successful sensing possibility should be lower bounded. Let p min be the threshold for the successful sensing possibility of IoT devices. When IoT devices execute sensing operations, the successful sensing probability should satisfy: Note that as the number of sensing operations increases, the IoT device achieves the higher sensing successful possibility.
However, the multiple sensing operations will lead to a longer sensing time and larger sensing energy consumption. For IoT device i, the sensing time T ses i is denoted as To process the generated status update in time, the sensing time should not exceed the sampling frequency. Otherwise, before the information of the status update is extracted, another new status update is generated by the IoT device, which make the information of the former status update outdated. Thus, the sensing time should satisfy the constraint: Let e i be the energy cost for IoT device i to detect the status information per bit sensed data, the energy consumption of one single sensing process is It is worth noticing that the IoT devices will not figure out whether the status update is generating successfully from the raw sensory data. Further processing operations are required to verify the validity of the generated status update. If the sensing process is failed, the sensory data will be removed and the control unit will send the request of generating another new status update to the IoT device. If the IoT device has generated a new status update before receiving the request, the request will not be further tackled with. Otherwise, the IoT device will restart the sensing process immediately regardless of the sampling interval.

C. Transmission Model
When finishing the sensing procedure and generating a new status update, the IoT devices need to further process the status update to verify the validity of status update and extract the status information. Since some IoT devices are limited in computation capability, they need to transmit their status updates to the edge server for further processing. Let x = {x 1 , x 2 , ..., x N } be the transmission policies for all the N IoT devices, in which the elements can be expressed as follows.
When the IoT device decides to transmit its status update to the edge server for processing, the transmission rate for the status update can be written as where B is the channel bandwidth allocated to the IoT device i, g i is the channel gain between device i and the edge node, p i represents the device i's transmission power, and ω 0 represents the background interference power. Then, the transmission latency is calculated as Besides, the transmission energy consumption can be expressed by

D. Computation Model
In this subsection, we introduce the computation model of the status update. Dependent on the different computation offloading strategies taken by the IoT devices, the time and energy to execute the computation tasks of the status updates are different. If the IoT device choose to process the status update with its own local processor, the computation latency is denoted as where f i represents the CPU frequency of the local processor in IoT device i. Besides, processing the computation task locally brings extra energy consumption to the IoT device itself, which is calculated as where δ is the energy consumption cost per CPU cycle. For the edge computing approach, the computation task is transmitted to the edge server for further processing and the computation latency is expressed by where f e denotes the CPU frequency of the edge server.

IV. AGE OF INFORMATION ANALYSIS
Note that the sensory information varies with time, so the freshness of status information has an essential impact on the accurate monitoring and controlling. We introduce the concept of AoI to evaluate the freshness of the status update generated by IoT devices. Let A i (t) be the AoI of the IoT device i with A i (0) = 0, and the AoI is defined as the time elapse from the last valid status update received by the control unit. One status update is valid to the control unit when the sensing process of the status update is success and the computation of the status update is finished. The AoI of the status update grows from the Beginning of the sensing, and keeps increasing until the next valid status update received by the control unit. Let T j,prcs i be the processing time to conduct j processing operations, and T j,prcs i = j × T 1,prcs i . Based on the different offloading strategies, the processing time of one single process operation is calculated as However, the sensing time might be too short for IoT devices to successfully generate a valid status update with only one sensing operation. After finishing the computation execution, the control unit may find the uploaded status update fail to meet the requirement, i.e. the sensing processing is not successful. Under such scenario, the status update will be dismissed and a request will be sent to the IoT device to repeat the sensing process to generate another status update. Theorem 1: For IoT device i, the average number of processing time for IoT devices to finish a processing task is Next, we derive the AoI of the status updates. Note that the information embedded in the status update makes sense after processing. The AoI at time t of the i-th IoT device is denoted as where a i (t) is the time when the latest status update generated by the IoT device i is successfully sensed and processed. Without loss of generality, we assume the initial observing time is t 1 = 0, and the initial AoI is ∆ 0 . As shown in the Fig.  3, the AoI grows linearly during the sensing and processing procedure and reset to a smaller value when a new status update is successfully accepted. Let t j be the time when the j-th status update generated and finish processing at the time t j . Let Y j denote the system time of the status update j, which is defined as where t u is the time when the next status update is successfully sensed and executed. Specifically, when the status update j is valid, Y j = t j , i.e. the finishing time of the status update j.
Besides, X j denotes the time between the generation of two continuous status update j and j + 1, which is given by Based on the definition above, the average AoI of the IoT device i is denoted as For the sake of simplicity, we consider the time interval with T = t n which is displayed in Fig. 3. To calculate the average AoI, the area is divided into several geometric parts which is expressed by the concatenation of polygons Q j . Hence, the average AoI is given by The area of the polygons are calculated differently. For j = 1, . For 2 ≤ j ≤ n, the area of the trapezoid Q j is calculated by the difference between two triangles, which is Besides, the area of the Q n+1 is the area of a triangle with a width of Y n . Hence, the equation (19) can be rewritten as As T becomes larger, i.e. T → ∞, the value of Q1+Qn+1 T can be ignored consequently and n−1 T can be treated as the value . From the analysis above, we have Considering the sensing model mentioned above, the value of E[X] is dependent on the the sampling interval, which is given by is identical to the average processing time of a successful status update E[T prcs i ]. Since X j is independent of Y j , we derive the average AoI as

A. Problem Formulation
For a IoT device, the freshness of the generated status update plays a key role in accurate monitoring and controlling. Hence, the AoI of the status update should be well considered when evaluating the performance of the IoT device. Besides, energy consumption is another significant performance metric due to the physical constraint of IoT devices, and the sensing, transmission and computation operations all consume the energy during the IoT devices running procedure. The average value of IoT device i is dependent on the energy consumption per time slot, which is given by As discussed above, the overhead of the computation offloading problem includes both the average AoI and energy consumption, which can be formulated as where µ t and µ e are the weight parameters of the AoI and energy consumption respectively. For all the IoT devices, the optimization objective is to minimize the total overhead, which is expressed by where D e is the data threshold of the MEC server. Constraints in (26b) ensure the sensing time for a IoT device will not exceed the sampling interval. Constraint (26c) guarantees the offloading decision for each IoT device is binary. Constraint (26d) is the lower bound of the sampling interval for IoT devices. Constraints (26e) is the lower bound of the successful sensing probability. Constraint (26f) means the upper bound of the data size of the MEC server.

B. Problem Decomposition
Considering s and x are both discrete variables, the feasible set of Problem (26a) is non-convex. Besides, the variables contains both continuous variables and discrete variables, which makes the optimization problem NP-hard [32]. In this part, we decompose the optimization problem into several subproblems: sampling interval optimization, sensing optimization and computation offloading optimization.
Sampling Interval Optimization: Due to the constraint (26b), the upper bound of the sensing time is dependent on the sampling interval of IoT devices. Hence, to obtain the optimal sensing time, the sampling period should be determined first. Note that the sampling interval has a great influence on the AoI and energy consumption of IoT devices. When the IoT devices generates status updates more frequently, i.e. the smaller τ i for IoT device i, the AoI decreases accordingly. However, the energy consumption will increase greatly due to the frequent sampling action. In this subproblem, we study the optimal sampling interval for IoT devices to achieve the trade-off between the AoI and energy consumption, which is denoted as Sensing Time Optimization: Based on the result of the sampling interval optimization, the upper bound of sensing time is fixed. With the more sensing times, the sensing successful probability is greatly improved. However, the excessive sensing operation may lead to unnecessary sensing latency and extra sensing energy consumption. To determine the suitable sensing time for IoT devices, the problem P is rewritten as Computation Offloading Optimization: After solving P 1 and P 2 , our goal is to find an optimal computation offloading policy for all the IoT devices to minimize the system overhead. The problem can be expressed as Although the MEC server is equipped with powerful computation capability, the more IoT devices choose to transmit computing tasks to MEC server will cause severe interference which may lead to extra time consumption. Based on the observations, we aim to optimize the computation offloading strategies for IoT devices to minimize the system overhead.

VI. JOINT OPTIMIZATION OF SENSING AND COMPUTATION
In this section, we optimize the sampling interval, sensing time, and computation offloading optimization respectively by solving the subproblems proposed above. Then, we design an iterative algorithm to solve the problem P to minimize the system overhead jointly.

A. Sampling Interval Optimization
In this part, we solve the sampling interval optimization problem P 1 mentioned in (27). Given the fixed sensing time and computation offloading policy, the value of T 1,prcs i Pi remains unchanged. Therefore, for sake of simplicity, the expression of P 1 can be rewritten as Since τ i is the continuous variable, we calculate the the derivative directly to discuss the variation trend to address the optimization problem. Then, the derivative of C t i (τ i ) is calculated as Due to the derivative of C t i (τ i ) are positive when τ i > τ * i and C t i (τ i ) is monotonic increasing, the optimal sample interval will be the lower bound if τ * i < τ min . Hence, the optimal sampling interval is expressed as

B. Sensing Time Optimization
In this part, the subproblem (28) is considered to determine the optimal number of the sensing time. Note that the value of T 1,prcs i and P i increases with s i and the value of C i (s i ) increases with T 1,prcs i and decreases with P i . Besides, when the offloading policy is fixed, the cost of transmission and processing is determined. From the analysis above, the value of system overhead is rewritten with respect to the sensing time as where Initialization: s i = 1; 3: end while 11: end for To minimize the system overhead, the variation trend of the objective function needs to be considered. To change the nonconvex feasible set into a convex set, we relax the discrete variable s i into real value variable as s i ∈ [0, +∞]. It can be verified that the function of C s i (s i ) is convex. Therefore, the value of C s i (s i ) first decreases with s i and increases with the increment of s i and there is only one optimal solution for s i . However, it is hard to achieve the optimal sensing time by directly solving ∂C s i (si) ∂si = 0. Considering the sensing time is discrete and has a upper bound, an enumerating algorithm is proposed to find the optimal sensing time, which is shown in Algorithm 1. For each IoT device, the sensing time is initially set as s i = 1. The number of sensing operations keeps increasing until the system overhead is no longer decreasing. Considering the computation complexity of Algorithm 1 is dependent on the sampling interval which is a constant and the number of IoT devices. Let τ be the average value of the sampling interval. The optimal sensing time s * i can be derived with the complexity no more than O (τ N ),

C. Computation Offloading Optimization
In this part, subproblem P 3 is solved to determine the optimal computation offloading policy with the aim of minimizing the system cost. From the conclusion of [33], the computation offloading decision-making problem can be transformed into the maximum cardinality bin packing problem, which is NPhard. Therefore, finding a central solution to the subproblem P 3 is NP-hard. In view of the complexity of the offloading computation optimization problem, game theory is introduced to provide the decentralized way to conduct the computation offloading decision making.
Before solving the offloading desicion making problem, the data size constraint of the MEC server need to be considered. Since the computation capacity of the MEC server is limited in practise, the number of data which can be processed at the same time is finite. When the data size of the MEC server exceed the threshold, the MEC server will not be able to serve the IoT devices any more. To meet the data constraint proposed in (26f), we design a MEC server availability request mechanism, which can be utilized to request for the computing resource before offloading the computing task to the MEC server for processing. By virtue of the MEC server availability request mechanism, IoT devices can perform rational decision making without violating the data constraint of the MEC server.
Specifically, when an IoT device finishes the sensing operation and generates a status update, the IoT device first makes a preliminary offloading decision making based on the requirement of its computing task and the network condition. Then, the IoT device will send a computation capability request with the data size of the status update to the MEC server to apply for the equivalent computation capability of the MEC server. When the MEC server receives the request, the MEC server first summarize all its computation tasks to determine whether its computation capacity upper bound is exceeded and the amount of spare computation capacity to be allocated to IoT devices. If N i=1 x i d i ≤ D e , the MEC server will permit the computation offloading request and sent the computation capacity f e to the IoT device. Otherwise, the data size of computing tasks transmitted to the MEC server is beyond the data threshold of the MEC server. To reasonably allocate the computing resource of the MEC server, the MEC server will list the IoT devices that are being served by the MEC server and eliminate the computing task with the most value of the data size continuously until the data threshold D e is satisfied again. For those IoT devices are eliminated from the service list, the MEC server will send a message with the assigned value 0 of computation capacity to the deleted IoT devices. Consequently, the processing time for those IoT devices is infinite with 0 allocated computation capacity, and the IoT devices will choose the local processing instead. By virtue of the MEC server availability request mechanism, the MEC server unavailability is addressed and the subproblem P 3 is transformed into the offloading decision making problem. Due to the data size of messages is relatively small, the communication overhead caused by the availability request mechanism can be ignored.
Then, we formulate the computation offloading decision making problem as a computation offloading game. Let x −i = {x 1 , . . . , x i−1 , x i+1 , . . . , x N } be the computation offloading policy of the other IoT devices except i. With the knowledge of the offloading strategies of other IoT devices, the IoT device i perform the offloading decision making to minimize the system cost, i.e.
The offloading decision making problem can be formulated as a strategic game Γ = {N , x, C i }, where the IoT device set N is the set of players, x is the set of strategies taken by players, and the system cost C i (x i , x −i ) is the objective function to be minimized. Then, we define the Nash equilibrium of the game Γ as Definition 3: A computation offloading strategy x * = {x * 1 , ..., x * N } is a Nash equilibrium if no IoT devices can further reduce the system overhead by unilaterally changing its own computation offloading strategy, i.e., For a multi-user computation offloading game, the Nash equilibrium guarantees that each IoT device at the Nash equilibrium will achieve a mutually satisfactory policy and have no incentive to deviate from its original strategy. The property is because if any IoT device is about to change its offloading policy, it should obtain lower system cost by updating offloading policy, which is contradictory to the definition the Nash equilibrium. Then, we define the best response for each IoT device: Definition 4: For IoT device i, the strategy x * i is the best response based on the policies of other users x −i , if the system cost satisfies that To achieve the Nash equilibrium, all the IoT devices tend to take the best response strategy. Lemma 1: An IoT device will achieve the lower system cost by offloading computing task to the MEC server for processing based on the offloading strategy x, if the received interference meets m∈N ,m =i x m g m,s p m ≤ L i , where L i is denoted as Proof: Please see the appendix B. Accordingly, the best response of the IoT device i can be expressed as Based on Lemma 1, the computation offloading strategy of IoT device i is mainly dependent on its own received interference. To prove that the existence of the Nash equilibrium in our proposed computation offloading game, we introduce the concept of the potential game [34]. Definition 5: A strategic game is called a potential game only if the variation of the utility function is proportional to the change of a certain function which is called potential function, i.e. there exists a potential function Φ(x) satisfying that for each IoT device i ∈ N , and any x i , x i ∈ x. Theorem 2: The computation offloading decision making game is a potential game and always has at least one Nash equilibrium and possess the finite improvement property. Proof: Please see Appendix C.
According to Theorem 2, we know that the computation offloading decision making problem can achieve the Nash equilibrium after finite iterations. Next, we propose a decentralized computation offloading decision making algorithm in Algorithm 2 achieve the mutually satisfactory offloading strategy for IoT devices.
To take the advantage of the finite improvement property of the potential game, we propose a decentralized computation offloading optimization algorithm to allow an IoT device to update its offloading strategy at one iteration. For each iteration slot, the update set is initialized as an empty set Algorithm 2 Decentralized Computation Offloading Optimization Algorithm Input: S, T. Output: Optimal computation offloading strategy x * . 1: Initialize the computation offloading strategy that each IoT device chooses to process its task locally, i.e. x i = 0, ∀i ∈ N ; 2: repeat for each iteration slot t 3: Initialize the update set κ = ∅.

4:
for each IoT device i ∈ N do 5: Compute the interference received by IoT device i based on x −i ; 6: Select the best response x * i for i according to (38); 7: Add IoT device i into the update set κ to compete for the updating opportunity; if κ = ∅ then 14: break; 15: end if 16: for each IoT device i in the update set κ do 17: Compute the improvement in the system cost by updating the offloading policy; 18: Broadcast a request message with ∆C i to contend for strategy update; 19: end for 20: for each IoT device i in the update set κ do 21: if i possesses the most improvement in the system cost then 22: Update the offloading strategy x i = x * i ; 23: Broadcast the decision update to all the other devices; 24: else 25: Choose the original offloading strategy for next iteration slot t + 1; 26: end if 27: end for 28: until κ = ∅ for several consecutive slots 29: return x * to record the IoT devices that have the incentive to update its offloading strategy. Based on the offloading strategies of other IoT devices x −i , each IoT device computes its received interference by m∈N ,m =i x m g m,s p m . Then, the IoT devices will select the best response strategy according to (38) and determine whether it needs to update its offloading strategy. If the best response is different from its current strategy, the device i will be added to the update set to compete for the opportunity to update the offloading strategy. After all the IoT devices decide their best responses, the devices in the update set will evaluate the improvement range of updating the offloading policy by where x * i = 1 − x * i is the original strategy of the device i. To improve the convergence speed of the iteration, the IoT device with the most improvement will win the competition and update its offloading strategy. The other devices will sustain their original offloading strategy and wait for the next iteration to contend for the updating opportunity. The offloading strategy will be continuously iterated until no device tends to update its offloading strategy for several consecutive iterations, and the optimal offloading policy x * is obtained. Since the most operations in Algorithm 2 are basic mathematical calculations, the computational complexity of one iteration is mainly dependent on the sort of the device with the most improvement. Since each device needs to perform the sorting operation, therefore the complexity of one iteration is O (N log N ). Assuming that I iterations are required to achieve the Nash equilibrium, the complexity of Algorithm 2 is O (IN log N ).

D. Algorithm Summary
In this subsection, we summarize the multi-variable iteration system cost optimization algorithm (MISCO) for joint sensing and processing optimization to minimize the system overhead. To solve the overall optimization problem (26a), we execute the iterations of the sensing, transmission and computation offloading optimization. First, we solve the optimal sampling period for each IoT device. Afterwards, based on the upper bound of the samping interval, we utilize the enumeration method to determine the optimal sensing time. Based on the result of the sampling and sensing optimization, a gametheoretic optimization algorithm is proposed to solve the optimal computation offloading strategy. Iterations of the sampling interval, sensing time and computation offloading optimization terminate when the disparity of the overall system costĈ = N i=1 C i between two consecutive iteration is below the threshold . The details of the proposed algorithm is summarized in Algorithm 3.
Based on the analysis above, the sampling interval set, the sensing time set and the computation offloading strategy are updated during the iteration process and the overall system cost keeps decreasing in each iteration. Considering the system cost has a lower bound and can only decrease finitely, the proposed multi-variable iterative optimization algorithm is convergent. Assuming K iterations are requisite to meet the disparity threshold, the complexity of Algorithm 3 can be expressed as O (KN + Kτ N + KIN log N ).

VII. SIMULATION RESULTS
In this section, we evaluate the performance of our proposed system overhead minimization algorithm by numerical results. We assume the coverage of the MEC server is a 50m×50m area, and N IoT devices are randomly distributed in the coverage area to execute the sensing tasks and generate the status updates. For sensing process, the time for executing a sensing task t unit i = 0.2 s, the sensing parameter = 0.08 and Algorithm 3 Multi-Variable Iterative System Cost Optimization Algorithm Input: Status update set U , distance set D, computation capacity f i and f e , ω 0 , channel gain g, transmission power p, sensing time unit t unit i . Output: Sampling interval T * , sensing time set S * , optimal computation offloading strategy x * . 1: Set r = 0 as the iteration slot. Initialize the sampling interval set T 0 , the sensing time set S 0 and the computation offloading strategy profile x 0 randomly; 2: repeat for each iteration slot r 3: Given the fixed S r and x r , solve the sampling interval T r+1 according to (33); 4: Given the T r+1 and x r , solve the sensing time S r+1 using Algorithm 1; 5: Given the T r+1 and S r+1 , solve the computation offloading strategy x r+1 using Algorithm 2; 6: Compute the overall system costĈ r+1 based on T r+1 , S r+1 and x r+1 ; 7: r = r + 1; 8: until |Ĉ r −Ĉ r−1 | < 9: return x * the energy consumption for sensing data e i is 10 −9 Joules/bit [10]. The task size of the status update to be offloaded d i is 500 KB and the number of CPU cycles required to process the status update c i is 1000 Megacycles. For wireless communication, the channel bandwidth is set as B = 100 Mhz, the transmission power of the IoT device p i is 100 mW, and the background interference ω 0 is -100 dBm [33]. The channel gain of each IoT device is calculated as where v is the distance between the IoT device and the MEC server and o is path loss coefficient set as 4. The computation capability for the IoT device f i is in a range of [0.8,1.0] Ghz, and the computation capability of the MEC server is 20Ghz. The processing power for IoT device to execute the computing tasks locally per CPU cycle is δ = 10 −11 (f i ) 2 [33].
To evaluate the effectiveness of our proposed algorithm, we introduce four comparative algorithm as benchmark: • Greedy Sensing Algorithm (GSA): The sampling interval is decided according to (33). The IoT devices will execute the least sensing operations to meet the sensing successful probability to achieve the least sensing latency. Then, the offloading decision-making is make by Algorithm 2. • Instant Sampling Algorithm (ISA): Each time when the previous status update finishes processing, the IoT device will conduct another sampling process to generate a new status update, which is similar to the zero-wait policy in [35]. To minimize the time cost, the IoT device will generate the status update instantly without waiting time.
The sensing time decision is made by Algorithm 1 and the computation offloading strategy is made by Algorithm 2. • Best Response Computation Offloading (BRCO) [28]: The sampling interval is decided by (33), and the sensing time is obtained from Algorithm 1. Each device chooses the best-response strategy based on the computing cost of interval and sensing time are determined in the same way as our proposed optimization algorithm. Then, all the computing tasks are offloaded to the MEC server for processing. We first evaluate the system cost of our proposed method. Fig. 4 shows the system cost of different methods with the different numbers of IoT devices. Compared with the other benchmarks, our proposed MISCO achieve the lowest system cost as the number of IoT devices increases. When the number of IoT devices is relatively small, there is not much difference between AECO and the other four comparative methods due to the small interference caused by IoT devices. Compared with the other two computation offloading optimization methods BRCO and AECO, our proposed method has a better performance in system cost as the number of IoT devices increases. With the larger number of IoT devices, the bandwidth for IoT devices to execute the task transmission is insufficient and the transmission cost improves greatly. Therefore, our computation offloading method perform a more rational offloading decision making. Fig. 5 shows the system cost with the different numbers of the CPU cycles required to process the status update. The numerical result displays the system cost of MISCO is lower than other benchmarks with more computation load of the status update. The system cost of ISA rises greatly because the longer process time of the status update make the status sampling out of date, while the increment of system cost of sensing optimization is relatively stable as the number of CPU cycles increases. With the improvement of the CPU cycle, the performance of MISCO will be closed to the AECO. Due to the hard computation load, all the IoT devices will choose to offload their tasks. Fig. 6 depicts the sensing time-processing time ratio with the different successful sensing probability under various computation loads. Note that the processing time here consists  of the transmission time and the task processing time. When the sensing successful probability threshold is relatively small, the sensing time-processing time ratio remains a stable level. Considering the threshold is easy to meet, the sensing time is determined by the sensing optimization method. With the requirement of the sensing successful probability threshold increases, more sensing operations need to be performed to satisfy the successful probability threshold, which causes more sensing time for IoT devices. Specifically, when the CPU cycle is 1000 Megacycles and the sensing successful probability threshold is more than 0.65, the sensing successful probability threshold has a great influence on the sensing-processing ratio. That is, the processing time dominates the ratio the sensing time-processing time ratio when the successful probability requirement is not strict and then the sensing time dominates with the high successful probability requirement. As the processing CPU cycle increases, the sensing time dominates at a higher level of successful probability due to the more processing time for status update. When the the CPU cycle is 1500 Megacycles, the sensing-processing ratio begin to increase when the sensing successful probability threshold is more than 0.7. The simulation result of the sensing time-processing time ratio with the different CPU cycles is shown in Fig. 7. When the computation load is small, the sensing time dominates the sensing-processing ratio. With the higher sensing successful probability threshold, the sensing time accounts for a higher proportion of the total time cost. As the number of CPU cycles increases, the sensing time as a percentage of total time decreases sharply. In the case of large number of CPU cycles, the sensing successful probability has little effect on the ratio of sensing time to processing time. The sensing-processing ratio remains at the same level for different successful probability thresholds, and it can be seen that processing time accounts for the major part of the total time at high computation load. Fig. 8 shows the impact of the different sensing successful probability threshold on the system cost. When the threshold value is at a low level, the system consumption will not be limited by the threshold and can be optimized to get the minimal system overhead directly by our proposed optimization algorithm. Therefore, the system cost will be maintained at a stable level. After the threshold value exceeds 0.7, the optimization method will be limited to achieve the optimal system overhead in order to meet the sensing successful rate requirement. When the CPU cycles for the task execution is small, the more obvious is the influence by the sensing successful rate threshold and the system cost rises more obviously. Therefore, the optimal threshold should be set to about 0.7 to ensure the sensing quality as well as the value of the system overhead.
In Fig. 9, the numerical result shows the system cost of our proposed MISCO with different sampling intervals. With the high sampling frequency limit, the system overheads for different task computations load are sustained at a stable value. When the sampling interval is greater than 1.4 s, the system overhead all starts to gradually increase. This means that the sampling interval limit at this point is greater than the optimal sampling interval solved by our proposed algorithm, and the excessively long sampling interval leads to an increase in the AoI, resulting in an increase in system overhead. To reduce the energy consumption of generating status updates and the  AoI of status update, the sampling interval threshold should be set lower than 1.4 s. Fig. 10 depicts the number of iterations of our proposed method with the different IoT devices numbers. Here the number of iteration contains the iteration number of Algorithm 2 to achieve the Nash equilibrium and the iteration number of Algorithm 3 to converge. The iteration number increases with the increasing of the IoT device number, which illustrates the convergence and scalability of our proposed MISCO. When the number of IoT devices is getting larger, the network resources are insufficient for the IoT devices. Therefore, all the IoT devices tend to process its computing tasks locally which makes the number of iterations reach an upper bound due to all devices stop iterating after choosing local execution.

VIII. CONCLUSION
In this paper, we first formulate the joint sensing and processing optimization problem to minimize the system overhead including the information freshness of the status updates and the energy consumption of IoT devices. The optimization problem is decomposed into three subproblems to optimize the sampling, sensing and computation offloading respectively. The sampling and sensing optimization problem are solved by extremum principles and game-theoretic method is utilized to perform the computation offloading decisionmaking. Afterwards, the multi-variable iterative optimization algorithm is proposed to minimize the system cost jointly. Numerical results depicts that the system cost achieved by our proposed method is lower than other comparative methods and the dominance of sensing and processing under different scenarios. Besides, the impact of the sensing probability and sampling interval thresholds are analyzed in the simulation.
Given the value of P i (s i ) is in the range of (0,1), let 1−P i (s i ) be a single variable ρ and ∞ n=1 n(1 − P i (s i )) n−1 can be further calculated as By substituting (42) into the expectation of execution time, the average number of processing time for a successful status update is calculated as APPENDIX B PROOF OF LEMMA 1 According to (14), (23) and (24), the lower system cost of transmitting computing task to the MEC server for processing is equivalent to Then, we can derive the threshold of the interference that achieves the lower system cost by offloading tasks to the MEC server for execution

APPENDIX C PROOF OF THEOREM 2
To prove the computation offloading decision making game is a potential game, we define the potential function as We consider an IoT device chooses to update its offloading policy with a lower system overhead, i.e. C i (x i , x −n ) < C i (x i , x −n ). From the definition of the potential game, the decrease of the system cost will lead to the decrease of the potential function. If the original offloading policy is to process the task locally, i.e. x i = 0, x i = 1, we derive C i (1, x −n ) < C i (0, x −n ), and m∈N \{i},xm=1 g m,s p m ≤ L i is meet. Then, we compute the change of the potential function by updating the offloading policy: For x i = 1, x i = 0, the result is similar to the argument above. According to the definition of the potential game, we conclude that the computation offloading decision making problem is a potential game.