Age of Computing: A Metric of Computation Freshness in Communication and Computation Cooperative Networks

All related papers can be divided into two broad categories. The first category investigates information freshness in edge and fog computing networks. The second category focuses on freshness-oriented metrics.

This paper introduces the Age of Computing (AoC), a novel metric designed to capture computation freshness in 3CNs (see Definition 3). The AoC concept is built on tasks’ arrival and completion timestamps, which makes it applicable to dynamic and complex real-world 3CNs. The AoC is defined under two types of deadlines: (i) soft deadline, i.e., if the task’s delay exceeds the deadline, the outcome is still usable but incurs additional latency; (ii) hard deadline, i.e., if the task’s delay exceeds the deadline, the outcome is discarded, and the task is considered invalid.

We then theoretically analyze the time-average AoC under both types of deadlines in a linear topology comprising a source, a transmitter, a receiver, and a computational node. Tasks arrive at the source at a constant rate and immediately enter a communication queue at the transmitter. After being transmitted/offloaded to the receiver, tasks are forwarded to the computational node for processing in a computation queue. The queuing discipline considered is first-come, first-served.

Under the soft deadline, we first derive a general expression for the average AoC (see Theorem 1). We then study a fundamental scenario where the task arrival process follows a Poisson distribution, and the transmission and computation delays adhere to exponential distributions—forming an M/M/1-M/M/1 system. In this case, we derive a closed-form expression for the average AoC (see Theorem 2). Subsequently, we extend our analysis to a more general scenario where the task arrival process follows a general distribution, and the transmission and computation delays also follow general distributions—resulting in a G/G/1-G/G/1 system. For this case, we derive the expression for the average AoC as well (see Theorem 3).

Under the hard deadline, we first derive a general expression for the average AoC (see Theorem 4). This expression involves intricate correlations, making it highly challenging to obtain a closed-form solution, even for an M/M/1-M/M/1 system. To address this, we provide an approximation of the average AoC and demonstrate its accuracy when the communication and computation rates are significantly larger than the task generation rate (see Theorem 5). We also define computation throughput as the number of tasks successfully fed back to the source per time slot (see Definition 4). A general expression for computation throughput is derived (see Lemma 1), along with an approximation (see Proposition 1). Furthermore, we explore the trade-off between computation freshness and computation throughput (see Lemma 2). In the end, we extend the accurate approximations for both the average AoC and computation throughput to more generalized scenario involving G/G/1-G/G/1 systems (see Theorem 6 and Proposition 2).

Finally, we apply the AoC concept to develop optimal real-time scheduling strategies focused on enhancing computation freshness in multi-source networks. Recognizing the importance of recent computational tasks, we adopt a preemptive scheduling rule. For real-time scenarios, we propose AoC-based Max-Weight policies for both deadlines (see Algorithms 1 and 2). By constructing a Lyapunov function (see (28)) and its drift (see (29)), we show that these policies minimize the Lyapunov drift in each time slot (see Propositions 3 and 4).

The remaining parts of this paper are organized as follows. Section II proposes and discusses the novel concept AoC. Section III and Section IV derive theoretical results for the AoC under the soft and hard deadlines, respectively. Section V designs real-time AoC-based schedulings in multi-source networks are proposed. We numerically verify our theoretical results in Section VI and conclude this work in Section VII.

In the network, the queuing despline follows a first-come first-serve approach. For any task $k$, let $\tau_{k}$ denote the arrival time at the source, $\tau_{k}^{\prime\prime}$ the time when the computation starts at the computational node, and $\tau_{k}^{\prime}$ the time when the computation completes. The delay of task $k$ is then defined as $\tau_{k}^{\prime}-\tau_{k}$. A task $k$ is considered valid if its outcome can be fed back to the source¹¹1The feedback is an acknowledgment message with a small bit size, commonly used in communication systems to confirm the successful receipt of data.; otherwise, it is deemed invalid.

Based on Definition 1, an informative task is a valid task that brings the latest information. The processing is the current task being processed, and the latest refers to the last completed task. The informative task and the latest task are not necessarily the same, i.e., $G(t)\geq N(t)$. They coincide ($G(t)=N(t)$) only when the latest task is also informative. At any time $t$, if the computational node is idle (no task is being processed), then the processing task is exactly the latest one, i.e, $P(t)=G(t)$. If the computational node is occupied (a task is being processed), then $P(t)=G(t)+1$. In summary, we have $P(t)\geq G(t)\geq N(t)$.

We define the index of lastest task within $[0,t]$ whose delay does not exceed the threshold $w$ as:

Under the soft deadline, we have $A(t)\leq N(t)\equiv G(t)$, while under the hard deadline, we have $A(t)\equiv N(t)\leq G(t)$. The computation freshness at the computational node is formally defined as follows.

The key distinction in Definition 3 lies in how computation freshness is assessed under hard and soft deadlines:

• •

  Under the hard deadline, computation freshness in (6) is determined solely by the informative tasks, as tasks with delays exceeding the threshold $w$ are deemed invalid.

• •

  Under the soft deadline, computation freshness in (3) accounts for both the informative tasks (i.e, $t-\tau_{N(t)}$) and an additional latency incurred if the task being processed experiences a significant instantaneous delay (i.e, $1_{\{P(t)>G(t)\}}\frac{A(t)}{G(t)}(t-\tau_{P(t)}-w)^{+}$). In particular, the additional latency includes $3$ components:

  • –

    The indicator function $1_{\{P(t)>G(t)\}}$ denotes whether a task is being processed at the computational node.

  • –

    The ratio $\frac{A(t)}{G(t)}$ represents the frequency of task delays exceeding the deadline up to time $t$, effectively quantifying the level/frequency of conflict with respect to the deadline (up to time $t$).

  • –

    The term $(t-\tau_{P(t)}-w)^{+}$ quantifies the amount by which the delay of the task currently being processed exceeds the threshold.

  • –

    This additional latency, calculated by the computational node, vanishes as soon as the current task is completed.

The concept of information freshness, known as AoI [5], reflects the cumulative delay over a given time period. Building on this foundation, AoC extends the notion to computational tasks, representing the cumulative delay associated with their processing. AoC provides a more comprehensive understanding of the timeliness of computations in a system. While related, AoC and AoI are fundamentally distinct in their definitions and physical interpretations: AoC evaluates the freshness of the informative task (may including an additional latency incurred by the task being processed), whereas AoI focuses on the freshness of the latest task.

Since the AoC $c_{x}(t)$ with $x\in\{\text{soft},\text{hard}\}$, captures the computation freshness at time $t$, we often consider the time-average AoC over a period to measure the computation freshness of a network. As $T\to\infty$, we define the average AoC of a network as

Finally, we summarize the important notations and their descriptions in the paper in Table I.

From (3) and (6), we observe that the only notation used is the timestamp, specifically the arrival timestamp $\tau_{k}$ and the departure timestamp $\tau_{k}^{\prime}$. To establish this concept, we intentionally avoid incorporating physical parameters such as bandwidth, GPU cycles, or caching. Instead, we focus solely on the use of timestamps. The reason for this choice is that the timestamp is the most fundamental and universally applicable metric that can be recorded by the destination (i.e., computational nodes) in any realistic 3CNs.

Let $m_{k}$ denote the timestamp when task $k$ reaches the receiver. The difference $m_{k}-\tau_{k}$ represents the transmission delay for task $k$, which is determined by the communication capability. This delay can be influenced by various network characteristics, such as bandwidth, information size, signal-to-noise ratio, channel capacity, network load, transmission protocols, and more. On the other hand, the difference $\tau_{k}^{\prime}-m_{k}$ represents the computation delay for task $k$, which depends on the computation capability. This delay is influenced by factors such as GPU cycles, task complexity, node load, memory size, access speed, I/O scheduling, and more. Finally, the total delay of task $k$, given by $\tau_{k}^{\prime}-\tau_{k}$, encompasses both the transmission and computation delays. As such, it is influenced by both the communication and computation capabilities. The AoC concept effectively captures the impact of both these factors on task performance.

The AoC concept is also applicable in dynamic and complex environments, such as mobile computing. In such settings, the communication network may experience interruptions or temporary failures due to factors like signal loss, interference, or mobility-related issues (e.g., moving out of network coverage). Tasks may experience temporary delays in a queue due to these disruptions. Nevertheless, the AoC concept remains applicable. To calculate the AoC, we only need the timestamps of tasks (i.e., $(\tau_{k},\tau_{k}^{\prime})$). As long as timestamps can be recorded, the AoC can be calculated, regardless of disruptions.

For analytical tractability, we consider a simplified model: (i) A task is represented by $(L,w,B)$, where $L$ denotes the task’s input data size, $w$ represents the maximum acceptable deadline, and $B$ indicates the computation workload [1]. (ii) The network is characterized by $(R,F)$, where $R$ is the data rate of the communication channel at the transmitter, and $F$ is the CPU cycle frequency at the computational node. (iii) The expected transmission delay of a task is $L/R$, and the expected computation delay is $B/F$. (iv) Both delays each follow their respective distributions. We define $\mu_{t}=R/L$ and $\mu_{c}=F/B$ as the communication rate and computation rate, respectively.

Let $h(t)=t-\tau_{N(t)}$ and $\hat{\epsilon}(t)=\frac{A(t)}{G(t)}$. From [5], the AoI concept shares the same formula as $h(t)$. Using the AoI curve as a benchmark, the AoC curve is depicted in Fig. 2. In Fig. 2 (a), the delay of task $k$ exceeds the threshold ($T_{k}>w$), but any waiting time before task $k$ is processed does not surpass the threshold. When the (instantenous) delay of a task is less than the deadline $w$, the AoC curve coincides with the AoI curve. However, when the (instantenous) delay of a task exceeds the deadline $w$, the portion of the delay exceeding the deadline increases at a rate $1+\hat{\epsilon}(t)$. In Fig. 2 (b), both the delay of task $k$ and the waiting time bofore task $k$ is processed ($\tau_{k-1}^{\prime}-\tau_{k}>w$) exceed the threshold. When the processing of task $k$ begins, an additional latency is introduced. As a result, at time $\tau_{k-1}^{\prime}$, there is an upwardjump (additional latency) of $\hat{\epsilon}(t)(\tau_{k-1}^{\prime}-w)$. Subsequently, the AoC curve increases at a rate $1+\hat{\epsilon}(t)$.

To uncover theoretical insights into the average AoC, we investigate it within queue-theoretic systems. We assume a stationary queuing discipline with a first-come, first-serve approach. On the source side, computational tasks arrive according to a stationary stochastic process characterized by a constant average rate. The inter-arrival between consecutive tasks is denoted by $X_{k+1}=\tau_{k+1}-\tau_{k}$. Upon arrival, each task experiences a transmission delay, denoted by $S_{k,t}$, at the transmitter, which follows a distribution with a constant expectation. Similarly, the computation delay denoted by $S_{k,c}$, at the computational node also follows a distribution with a constant expectation. Let the delay of task $k$ be denoted by $T_{k}$. In queuing systems, this delay is referred to as the system time, and we use these terms interchangeably. Under the stationary queuing discipline, $\{X_{k}\}_{k}$, $\{S_{k,t}\}_{k}$, $\{S_{k,c}\}_{k}$, and $\{T_{k}\}_{k}$ are i.i.d, respectively.

In this section, we let the inter-arrival $X_{k}$ follows an exponential distribution with parameter $\lambda$, meaning that computational tasks arrive at the source according to a Poisson process characterized by an average rate of $\lambda$. Let $S_{k,t}$ and $S_{k,c}$ have exponential distributions with parameters $\mu_{t}$ ($=R/L$) and $\mu_{c}$ ($=F/X$), respectively. In other words, the network forms an M/M/1-M/M/1 tandem.

In this section, we let the inter-arrival $X_{k}$ follows a general distribution with $\mathbb{E}[X_{k}]=1/\lambda$, meaning that computational tasks arrive at the source according to a general stochastic process characterized by an average rate of $\lambda$. Let $S_{k,t}$ and $S_{k,c}$ have general distributions with $\mathbb{E}[S_{k,t}]=1/\mu_{t}$ and $\mathbb{E}[S_{k,c}]=1/\mu_{c}$, respectively. In other words, the network forms an G/G/1-G/G/1 tandem.

To obtain the average AoC, it is necessary to know the stachastic information about the inter-arrival interval, the service delay at the transmission and computation nodes, and the system time of a task in both the transmission and computation queues. Let the system times of a task in the transmission and computation queues be denoted as $U_{k,t}$ and $U_{k,c}$, respectively.

Note that sequences $\{S_{k,t}\}_{k}$, $\{S_{k,c}\}_{k}$, $\{U_{k,t}\}_{k}$, and $\{U_{k,c}\}_{k}$ are i.i.d with respect to $k$, respectively. The correpsonding density functions are denoted by $f_{X}$, $f_{S_{t}}$, $f_{S_{c}}$, $f_{U_{t}}$, and $f_{U_{c}}$, respectively. The joint density function of $U_{k,t}$ and $U_{k,c}$ is denoted as $f_{U_{t},U_{c}}$. The following assumptions are then required.

Based on Assumption 1, the following steps can be taken:

• •

  By integrating $f_{U_{t},U_{c}}$, we can obtain the marginal density functions $f_{U_{t}}$ and $f_{U_{c}}$.

• •

  Since $S_{k,t}$ (respectively, $S_{k,c}$) is independent of $U_{k,t}-S_{k,t}$ (respectively, $U_{k,c}-S_{k,c}$), and the marginal density functions $f_{U_{t}}$ and $f_{U_{c}}$ are avaibale, we can derive the density functions of the waiting times in both queues, namely $f_{U_{t}-S_{t}}$ and $f_{U_{c}-S_{c}}$, through inverse convolution.

• •

  Given that $f_{U_{t}-S_{t}}$, $f_{U_{c}-S_{c}}$, and $f_{U_{t},U_{c}}$ are known, we can again apply inverse convolution to derive the joint density functions $f_{U_{t},U_{c}-S_{c}}$ and $f_{U_{c},U_{t}-S_{t}}$.

From (6) in Definition 3, under the hard deadline, $c_{\text{hard}}(t)$ is solely determined by informative tasks. When $w=0$, all tasks are considered invalid, leading to $c_{\text{hard}}(t)=t$, which increases linearly with time $t$. Conversely, when $w=\infty$, there is no dedline, and all tasks are considered valid. In this case $G(t)=N(t)$ for all $t$, so $c_{\text{hard}}(t)=t-G(t)$, which is only affected by the lastest task.

The AoC curve is depicted in Fig. 3, with the curve of AoI (see [5]) as a benchmark. In this figure, task $k-1$ is valid, so both AoI and AoC decreases at time $\tau_{k-1}^{\prime}$. Suppose that after task $k-1$, the next valid task has the index $k-1+M$. Here, $M$ is a random varibale with the distribution

From (IV-A), $M\geq 1$. Since the network is stationary, the random variable $M$ associated with every valid task has the identical distribution as in (IV-A). The AoC does not decrease at times $\tau_{k}^{\prime}$, $\tau_{k+1}^{\prime}$, $\cdots$, $\tau_{k+M-1}^{\prime}$, and decreases at time $\tau_{k+M}^{\prime}$. In the interval $[\tau_{k-1}^{\prime},\tau_{k+M}^{\prime})$, the AoC increases linearly with time $t$.

Although the general expression for the average AoC is given by (13), a further exploration on this expression is challenging due to a couple of correlations involved. These correlations are detailed as follows.

• (i)

  Correlation between delays: In the queuing system, if the delay of task $k$, $T_{k}$, increases, the waiting time for task $k+1$ also increases, leading to a larger delay for task $k+1$, $T_{k+1}$. Hence, the sequence $\{T_{k}\}_{k}$ consists of identical but positively correlated delays.

• (ii)

  Correlation between delays and $M$ (defined in (IV-A)): According to (IV-A), $M$ is the first index $n$ such that $T_{n}\leq w$ while all previous $T_{k}>w$. A higher value of $T_{k}$ suggests a higher likelihood of subsequent $T_{j}$ values (for $j>k$) also being high, thus making $M$ larger because it takes longer for a $T_{k}$ to be less than or equal to $w$. This indicates that $T_{k}$ are $M$ are positively correlated.

• (iii)

  Correlation between the inter-arrival times $X_{k}$ and delays $T_{k}$: If $X_{k}$ is larger, meaning that the inter-arrival time between task $k-1$ and task $k$ is longer, then $T_{k}$ is likely smaller because the waiting time for task $k$ is reduced. Therefore, $T_{k}$ and $X_{k}$ are negatively correlated.

• (iv)

  Correlation between the inter-arrival times $X_{k}$ and $M$: Since $X_{k}$ are $T_{k}$ are negatively correlated, and $T_{k}$ and $M$ are positively correlated, $X_{k}$ and $M$ are negatively correlated.

Due to all these correlations, it is extremely challenging to derive the closed-form expression for $\Theta_{\text{hard}}$ in (13). However, we can approximate it accurately under specific conditions.

By exchanging $\mu_{t}$ and $\mu_{c}$ in (5) and (5), we observe that $\Theta_{\text{soft}}$ remains unchanged. This indicates that $\Theta_{\text{soft}}$ is symmetric with respect to $(\mu_{t},\mu_{c})$. From a mathematical standpoint, this symmetry implies that both communication latency and computation latency equally affect $\Theta_{\text{soft}}$. Therefore, in practical terms, to improve the computation freshness $\Theta_{\text{soft}}$, one can reduce either the communication latency or the computation latency, as both have the same impact on the overall freshness.

Unlike the hard deadline, the frequency of informative tasks is influenced by two facts: the arrival rate $\lambda$ and the deadline $w$. We define the frequency of informative tasks as computation throughput. Formally, we have the following definition.

In (18), the arrival rate $\lambda$ is reflected in $X_{k}$, while the deadline $w$ is captured by $M$. It is worth noting that Definition 4 can apply to the case with a soft deadline. Under the soft deadline, (17) implies that $\Xi=\lim_{t\to\infty}\frac{N(t)}{t}=\lim_{t\to\infty}\frac{G(t)}{t}=\lambda$, which is a trivial case. Therefore, we did not investigate the computation throughput concept in Section III.

A Pareto-optimal point represents a state of resources allocation where improving one objective necessitates compromising the other. A pair $(\hat{\Theta}^{*},\hat{\Xi}^{*})$ is defined as a Pareto-optimal point if, for any $(\hat{\Theta},\hat{\Xi})$, both conditions (i) $\hat{\Theta}<\hat{\Theta}^{*}$ (or $\hat{\Theta}\leq\hat{\Theta}^{*}$) and (ii) $\hat{\Xi}\geq\hat{\Xi}^{*}$ (or $\hat{\Xi}>\hat{\Xi}^{*}$) cannot hold simulatenously [27]. This indicates that reducing computation freshness is impossible without degrading computation throughput, and increasing computation throughput cannot occur without compromising computation freshness.

While closed-form expressions for computation freshness (see (13)) and computation throughput (see (18)) are unavailable, their relationship can be approximated using (14) and (19), the analysis focuses on weakly Pareto-optimal points rather than strict Pareto-optimal points [28]. Consider the following optimization problem:

Let the corresponding $\hat{\Theta}$ and $\hat{\Xi}$ as $\hat{\Theta}(u)$ and $\hat{\Xi}(u)$, respectively. The tradeoff between computation freshness and the computation throughput is explored in the following lemma.

In this section, we extend the average AoC in M/M/1-M/M/1 tandems (see Section IV-B) to general case, i.e., G/G/1 - G/G/1 tandems: Computational tasks arrive at the source via a random process characterized by an average rate of $\lambda$. Upon arrival, the tranmission delay of each task follows a general distribution with an average rate of $\mu_{t}$, and the computation delay at the computational node follows a general distribution with an average rate of $\mu_{c}$.

Consider a network with a computational node processing tasks from $N$ sources, as illustrated in Fig. 4. Time is slotted, indexed by $k\in\{1,2,\cdots,T\}$, where $T$ is the time-horizon of this discrete-time system. In every time slot, computational tasks arrive source $i$ with rate $\lambda_{i}$. Upon arrival, tasks are immediately available at the corresponding transmitter $i$, where they enter a communication queue awaiting transmission. Transmitter $i$ transmits tasks at a rate $\mu_{t,i}$: if a task is under transmission during a slot, the transmission completes with probability $\mu_{t,i}$ by the end of the slot. Once transmitted, the tasks are received and cached by the receiver, where they await processing. The computational node processes tasks at a rate $\mu_{c}$. Without loss of generality, we assume $\mu_{c}=1$, the framework can be straightforwardly extended to cases where $\mu_{c}<1$. After processing, tasks depart from the system. In most realistic scenarios, recent computational tasks hold greater importance than earlier ones, as they often contain fresher and more relevant information. To address this, we adopt a preemptive rule [6, 8]: newly arrived tasks can replace previously queued tasks already present in the transmitter.

At each slot, the receiver either idles or selects a transmitter to transmits its task. Let $a_{i}(k)\in\{0,1\}$ be an indicator function where $a_{i}(k)=1$ if transmitter $i$ is selected for transmission in time $k$, and $a_{i}(k)=0$ otherwise. Similarly, let $d_{i}(k)=1$ indicate that a task from transmitter $i$ successfully reaches the receiver at slot $k$. Due to limited communication resources, at most one task can be transmitted across all transmitters in a given slot. Therefore, the following constraints hold:

Additionally, if a task is successfully transmitted ($\sum_{i=1}^{N}d_{i}(k)=1$), the reicever schedules a transmitter for the next time slot ($\sum_{i=1}^{N}a_{i}(k+1)=1$). Conversely, if no task is delivered ($\sum_{i=1}^{N}d_{i}(k)=0$), the receiver does not schedule a transmitter for the next slot ($\sum_{i=1}^{N}a_{i}(k+1)=0$). This relationship is formalized as: $\sum_{i=1}^{N}a_{i}(k+1)=\sum_{i=1}^{N}d_{i}(k)$.

Let $c_{i}^{x}(k)$ with $x\in\{\text{soft},\text{hard}\}$ be the AoC associated with source $i$ at the end of slot $k$. The time-average AoC associated with source $i$ is given by $\mathbb{E}[\sum_{k=1}^{T}c_{i}(k)]/T$. For capturing the freshness of computation of this network employing scheduling policy $\pi\in\Pi$, we define the average sum AoC in the limit as the time-horizon grows to infinity as

The AoC-optimal the scheduling policy $\pi^{*}\in\Pi$ is the one that minimizes the average sum AoC:

At the end of this subsection, we introduce the concept of instantaneous delay for transmitter $i$, denoted as $z_{i}(k)$. In particular, $z_{i}(k)$ represents the instantaneous delay of current task in time slot $k$. If the transmitter is idle during slot $k$, then the delay is defined as $z_{i}(k)=c_{i}^{x}(k)$.

Finding the global optimal policy for the optimization problem (27) is challenging due to the real-time nature of scheduling decisions. Drawing inspiration from [29], we employ Lyapunov Optimization to develop AoC-based Max-Weight policies. This policy have been shown to be near-optimal [29, 30]. The Max-Weight policy is designed to minimize the expected drift of the Lyapunov function in each time slot, thereby striving to reduce the AoC across the network.

We use the following linear Lyapunov Function:

where $\beta_{i}$ is a positive hyperparameter that allows the Max-Weight policy to be tuned for different network configurations and queueing disciplines. The Lyapunov Drift is defined as

where $\Xi(k)$ represents the network state at the beginning of time slot $k$²²2Here, we define $\Delta\big{(}\Xi(k)\big{)}=\mathbb{E}[L(k+2)-L(k)|\Xi(k)]$ instead of $\Delta\big{(}\Xi(k)\big{)}=\mathbb{E}[L(k+1)-L(k)|\Xi(k)]$ as in [29]. This adjustment is made because when a transmitter is scheduled, the corresponding task requires at least 2 time slots to complete the computation., which is defined by

The Lyapunov Function $L(k)$ increases with the AoC of the network, while the Lyapunov Drift $\Delta\big{(}\Xi(k)\big{)}$ represents the expected change in $L(k)$ over a single slot. By minimizing the drift (29) in each time slot, the Max-Weight policy aims to maintain both $L(k)$ and the network’s AoC at low levels.