Intelligent Data-Enabled Task Offloading for Vehicular Fog Computing

Abstract

Fog computing is a key component of future intelligent transportation systems (ITSs) that can support the high computation and large storage requirements needed for autonomous driving applications. A major challenge in such fog-enabled ITS networks is the design of algorithms that can reduce the computation times of different tasks by efficiently utilizing available computational resources. In this paper, we propose a data-enabled cooperative technique that offloads some parts of a task to the nearest fog roadside unit (RSU), depending on the current channel quality indicator (CQI). The rest of the task is offloaded to a nearby cooperative computing vehicle with available computing resources. We developed a cooperative computing vehicle selection technique using an artificial neural network (ANN)-based prediction model that predicts both the computing availability once the task is offloaded to the potential computing vehicle and the link connectivity when the task result is to be transmitted back to the source vehicle. Using detailed simulation results in MATLAB 2020a software, we show the accuracy of our proposed prediction model. Furthermore, we also show that the proposed technique reduces total task delay by 37% compared to other techniques reported in the literature.

1. Introduction

Vehicular networks are important components of future intelligent transportation systems (ITSs). These networks equip vehicles with wireless transmitters and receivers, thus enabling them to share traffic information with other vehicles and the cloud [1,2]. As a result, city-level traffic information can be collected and used to manage congestion on the roads and implement safe driving practices [3,4,5,6].

Due to the increasing number of ITS applications, the data shared among ITS entities (including vehicles and infrastructure nodes, known as roadside units) are growing at a rapid pace [7,8,9,10]. Also, these ITS applications require the computation of several application-related tasks, such as decisions on particular driving actions using the current state of traffic in the vicinity. Thus, fog computing nodes, in the form of roadside units (RSUs), are needed to manage the data collection and computation of application-related tasks [11,12,13,14]. Vehicles offload their tasks to nearby RSUs, which act as fog nodes and provide computation services [15,16].

Task offloading in vehicular fog computing works in four steps. In the first step, the appropriate fog node for a given task is selected [17]. This decision is made based on several factors, such as the workloads of fog nodes, the channels between vehicles and fog nodes, etc. In the second step, the task is transmitted to the selected fog node using wireless communication technology, such as 6G [18,19]. In the third step, the task is computed at the fog node. Finally, the last step involves transmitting the result of the task back to the vehicle [20,21].

A major challenge in vehicular fog computing is the consideration of vehicle mobility and dynamic wireless channel quality for making task offloading decisions [22]. In addition, other factors, such as computing resource availability at fog nodes, the distances between vehicles and fog nodes, etc. also need attention. Moreover, the offloading ratio, which dictates the percentage of tasks that are computed locally by the vehicle itself, also needs to be decided.

Neighborhood vehicles that have available computing resources can also share their resources with task-generating vehicles, thus computing the tasks even closer than fog RSUs. While fog RSUs have much higher computing capacities, they also have higher computing loads that are generated by several vehicles in their range. Similarly, there are scenarios where the channel quality between vehicles, fog RSUs and task-generating source vehicles is not good. Thus, transmitting tasks to fog RSUs may result in higher transmission delay and increased overall task delay. Thus, cooperative computing by neighborhood vehicles will play an important role in supporting fog RSUs in managing task computation within vehicular networks.

In this paper, we propose a data-enabled task offloading technique for vehicular fog computing. The key contributions of the proposed work are as follows:

• We consider a scenario in which vehicles use fog RSUs and other nearby vehicles to compute a task. A vehicle with a task to compute offloads some percentage of the task to a fog RSU, based on the channel quality indicator (CQI) of the link with the fog RSU. The remaining task is offloaded to a cooperative computing vehicle in its neighborhood.
• We propose a cooperative computing vehicle selection algorithm, based on the metrics of link connectivity time and computing availability time. These metrics consider factors such as source vehicle speed, potential computing vehicles’ speed, distance between vehicles, the computing loads of vehicles and channel quality between vehicles.
• We propose an ANN-based prediction model to predict the values of the link connectivity time and computing availability time of potential cooperative computing vehicles. This prediction helps to evaluate the computing loads at the potential cooperative computing vehicles once the task has been transmitted and find the link connectivity value once the task result is transmitted back from the potential computing vehicle to the source vehicle.
• We present detailed simulation results to show the high accuracy of the proposed prediction model. Moreover, we also implement the complete task offloading process and show that task delay is significantly reduced when using the proposed technique compared to using matching-based task offloading techniques.

The paper is organized as follows: Section 2 reviews recent work related to task offloading in vehicular fog computing; Section 3 presents the system model considered in the paper; Section 4 explains the working of the proposed technique; Section 5 discusses the performance evaluation and simulation results; Section 6 presents our conclusions.

2. Literature Review

In this section, we review the recent literature related to task offloading in vehicular fog computing. A summary of the literature review is presented in

Table 1. Recent work conducted in vehicular fog computing.

Ref.	Scenario	Proposed Technique	Design Objective
[23]	Vehicular fog computing	Online learning-based offloading	1. Resources are shared between fog nodes while maintaining lower computation costs 2. Task allocation decisions and spectrum scheduling are used to minimize offloading delay
[24]	Vehicular fog computing	Convex–concave optimization and price-matching task offloading	1. The efficient assignment of servers is achieved via the convex–concave optimization approach while maximizing the anticipated utility of the operator 2. The total delay of the network is minimized using a price matching solution
[25]	Vehicular fog computing	Contract theoretical modeling and stable matching algorithm	1. Based on contract theoretical modeling, a mechanism is proposed to maximize the projected utility of BS 2. A stable matching algorithm is used for task assignment amongst user equipment and vehicles
[26]	Vehicular fog computing	Contract theory and learning -based matching	1. A contract theory computing resource management mechanism is proposed 2. A learning-based matching task offloading method is also proposed
[27]	Multi-vehicular fog computing	Deep reinforcement learning	1. Resources are allocated while reducing the complexity of the system 2. A queuing model is proposed to solve the collision problem faced by simultaneous offloading
[28]	Multi-vehicular fog computing	Lagrange dual approach	1. A low-complexity algorithm is proposed to find the optimized values of offloading ratios, which vehicles to select and the consumption of the system
[29]	Vehicular fog and cloud computing	Semi-Markov decision process	1. The task offloading problem is presented as a semi-Markov decision process 2. A value iteration algorithm is proposed to maximize the total long-term reward of the system
[30]	Vehicular fog computing	Stable matching	1. Vehicle mobility is considered while offloading 2. The Kuhn–Munkres algorithm is used to find a stable match

.

In [23], the authors put forth the significance of fog computing by efficient task offloading for mobile devices. To deal with delay-sensitive applications, an online learning-based offloading approach is applied in two stages. In the first stage, resources are distributed between fog nodes while keeping computation costs at a minimum. In the later stage, offloading delay is minimized by optimizing task allocation and spectrum scheduling. Simulation results show the performance gain of the proposed technique compared to the upper confidence bound (UCB) technique.

The work in [24] involves the efficient engagement of servers for computing, as well as the offloading of tasks under the uncertainty and asymmetry of the transmitted information. A two-phase-based design is proposed to achieve this goal. For the efficient assignment of servers, a convex–concave optimization approach is defined while maximizing the anticipated usage of the operator under the condition of symmetric information. Additionally, to minimize the total delay of the network, a price-matching solution is also proposed. This price matching is extended to information uncertainty scenarios and a matching-based offloading framework is developed, which helps to minimize total delay. Their results show that the proposed algorithm achieves the efficient sharing of resources without requiring global information and assures the bounded divergence of the algorithm.

Vehicular fog computing (VFC) is employed in [25], where the computation task is offloaded from a base station (BS) to underutilize the computational resources of vehicles in the vicinity. Major challenges in VFC, such as the absence of efficient incentives and mechanisms for task assignment, are presented. Firstly, a mechanism for efficient incentives is proposed, which is based on contract theoretical modeling, in which a contract is designed by examining the distinctive characteristics of every vehicle type to maximize the projected utility of the BS. The problem of task assignment is converted into a dual-sided matching problem between user equipment and vehicles, which is resolved by using a stable matching algorithm that is based on pricing. Their numerical results show a substantial performance improvement when using the proposed technique.

Autonomous driving is a promising paradigm for enabling C-ITS. A significant amount of computation, as well as delay-intensive response, is needed to deal with autonomous driving. Therefore, in [26], VFC is applied to migrate computing resources from overcrowded BSs to nearby vehicles. Two-stage-based VFC architecture is suggested to address the challenges of server assignment and task processing tactics under the assumption of information asymmetry and uncertainty. Vehicular computing resources are managed according to contract theory and the efficient offloading of tasks is governed by learning-based matching. Their simulation results also exhibit improvements in performance, in terms of both resource management and offloading delay.

VFC can also contribute to load issues in highly congested areas during peak times. Thus, vehicles can be assumed to be fog nodes, which are then used to assist in computing offloaded tasks. However, there are some concerns regarding the deployment of VFC, like the deficiency of incentives for the distribution of resources, the increased complexity of systems and collisions between offloading vehicles. An innovative contract-based procedure is proposed in [27] whereby joint resource contribution and utilization are achieved via deep reinforcement learning. The aim is to distribute resources while reducing the complexity of the system. Furthermore, to handle the collision problem in simultaneous offloading in multiple vehicle scenarios, a queuing model is also proposed. Their results show that the performance of both task offloading and resource allocation is significantly improved.

Similar to the above model, in [28], the authors present the idea of vehicles enabled with computation capabilities, which ensures less latency and enhancements in overall system efficiency. A major issue faced in this scenario is how and which vehicle is to be selected for task offloading when taking into consideration the delay costs and resource allocation for the multi-vehicle model. A convex optimization problem is formulated for the consumption function of the offloading model, which is then subjected to inequality constraints. Further, this problem is solved using the Lagrange dual approach and, in the end, a low-complexity algorithm is designed to find the optimized values of offloading ratios, the selection of computing vehicles and the consumption of the system.

Vehicular fog and cloud computing (VFCC) systems may consume large computing power for processing numerous computation-intensive and delay-sensitive tasks. To solve this problem, in [29], an optimal offloading scheme is proposed that takes into account the departure of occupied vehicles. Task offloading is formulated as a semi-Markov decision process (SMDP) and a value iteration algorithm is used to maximize the utility of the system. Compared to the greedy scheme, the proposed algorithm achieves higher utility.

In [30], the authors propose a task offloading technique for vehicular networks. The key idea is to use the stable matching technique to find the most suitable fog node for a given task. Vehicle mobility and dynamics are considered in the developed algorithm and a one-to-one matching technique based on the Kuhn–Munkres algorithm is used to find a stable match. Their results show that the task offloading rate is improved by the proposed technique.

In addition, there are several intelligent routing protocols for vehicular networks that are also used to transmit packets from vehicles to fog nodes [31,32,33,34,35]. These algorithms utilize techniques, such as fuzzy logic, genetic algorithms and machine learning, to obtain information about optimal routes.

3. System Model

In this paper, we consider a segment of a bidirectional multi-lane highway that contains N number of vehicles and several RSUs located along the road. The RSUs serve as fog nodes, thus providing computing services to the vehicles, as shown in Figure 1. The RSUs are connected to the cloud server via optical fiber links. The time taken to transmit tasks between neighboring RSUs and from RSUs to the cloud is considered negligible. Each vehicle is equipped with a communication device that allows for communication with nearby vehicles and other RSUs.

3.1. Mobility Modeling

For the vehicle mobility modeling, we assume that each vehicle has a random initial speed $s_i$, which is independent of the speed of other vehicles. As time progresses, the speed of the vehicle changes but remains within a uniformly distributed speed range. Thus, fast-moving vehicles can overtake slower vehicles using the other lane.

3.2. Data Sharing Model

Vehicles periodically share traffic information and RSUs every 100 ms using wireless communication [6]. Furthermore, vehicles also share the current status of their computational resources in the form of a metric we define in this paper as computation availability time $T_{ca}$. This is defined as the time after which the vehicle’s computational resources will become available. Thus, it measures the busy time of a vehicle’s computational resources and is calculated directly from the computational latency of the current task allocated to the vehicle. $T_{ca}$ is given by the following equation:

$$T_{ca}=\frac{W{C}_b}{C}$$

(1)

where W measures the task size (given in bits), $C_b$ is the number of cycles taken by the vehicle’s CPU to compute one bit (given in cycles/bit) and C is the frequency of the vehicle’s CPU (given in cycles/s).

3.3. Computational Model

Our proposed work considers task offloading at fog nodes, as well as cooperative vehicles. Let $\alpha$ be the offloading ratio, which is defined as the percentage of a task that is offloaded to a fog node. The remaining percentage of task $1-\alpha$ is offloaded to a cooperative vehicle. The computational delay is the sum of the two task delays (i.e., task delay at the fog node and task delay at the cooperative vehicle) multiplied by the respective percentage of the offloaded task.

$$T_{comp}=(1-\alpha )\times T_{ca}+\alpha \times T_{fog}$$

(2)

where $T_{ca}$ is the task delay at the cooperative vehicle and $T_{fog}$ is given as follows:

$$T_{fog}=\frac{W{C}_b^{fog}}{C^{fog}}$$

(3)

where $C_b^{fog}$ is the cycles/bit of the fog node and $C^{fog}$ is the frequency of the CPU at the fog node (measured in cycles/s).

4. Proposed Technique

In this section, we explain the working of the proposed technique, which is divided into two major parts. The first part evaluates the offloading ratio of the task to the nearest fog node, whereas the second part finds the best cooperative computing vehicle to compute the rest of the task. A flow chart for the proposed technique is shown in Figure 2.

4.1. CQI-Based Offloading to Fog Nodes

The key idea of the first part of the proposed technique is to offload the task to the nearest fog node, depending on the channel quality between the task node and the fog node. In a vehicular network, RSUs regularly send pilot signals to vehicles for control and synchronization purposes. The received signal strength of these pilot signals is mapped to a 4 bit value (varying from 0 to 15), known as the channel quality indicator (CQI), which is a measure of channel conditions between RSUs and vehicles. These CQI values are periodically reported by each vehicle to RSUs.

Let $v_s$ be the source vehicle and $r_s$ be the connected fog RSU. We take $\alpha (v_s,r_s)$ as the offloading ratio of the task transmitted from $v_s$ to $r_s$. The proposed technique uses the mapped CQI value obtained at $v_s$ to find $\alpha (v_s,r_s)$, as follows:

$$\begin{array}{cc}\hfill \alpha (v_s,r_s)& =\frac{1}{1+e^{-c_1((CQ{I}_{max}-CQ{I}_{v_s,r_s})-c_2)}}\hfill \end{array}$$

(4)

Equation (4) is a logistic function, known as sigmoid. Here, $CQ{I}_{max}$ is the maximum CQI value of 15. Based on the values of $c_1$ and $c_2$, the sigmoid function returns a different value for the offloading ratio for different $CQ{I}_{v_s,r_s}$ values. A key feature of the sigmoid function used in Equation (4) is that it returns a higher offloading ratio if the channel conditions are good, i.e., $(CQ{I}_{max}-CQ{I}_{v_s,r_s})$ is less. As channel conditions deteriorate, the offloading ratio significantly reduces.

4.2. Cooperative Computing Vehicle Selection and Task Offloading

As the source vehicle offloads part of the task to a fog RSU, the remaining part of the task is offloaded to a cooperative computing vehicle, which is selected using an ANN-based prediction algorithm. The key idea of the second part of the proposed technique is to predict which neighborhood vehicles will have long-term connectivity with the source vehicle and also have low computation available time (which means that the cooperative vehicle’s CPU will be available sooner). When the source vehicle $v_s$ has a task to offload, it will request an RSU to nominate the most suitable cooperative computing vehicle for task offloading.

To find the optimal cooperative vehicle, we utilize two key metrics. The first metric is known as link connectivity time, which calculates the time for which the two vehicles (moving either in the same direction or opposite directions) will remain connected [36,37] and is calculated using the following equation:

$$T_{i,j}^{LLT}=\frac{-\Delta s_{i,j}\Delta d_{i,j}+|\Delta s_{i,j}|R}{{(\Delta s_{i,j})}^2}$$

(5)

where $\Delta s_{i,j}$ is the relative speed, $\Delta d_{i,j}$ is the relative distance between the two vehicles and R is the communication range dictated by channel conditions.

The second metric used to find the optimal cooperative computing vehicle is the computation available time, which was already explained in Section 3. Each RSU gathers traffic information for all vehicles within its communication range.

Once a request from source vehicle $v_s$ to find the optimal cooperative computing vehicle is received at the RSU, it selects all j neighborhood vehicles of $v_s$ that have a $T_{s,j}^{LLT}$ greater than a selected threshold. This threshold is selected based on the time taken for the task to be computed and received back at $v_s$. The rationale for choosing such a threshold is to make sure that the source vehicle and cooperative computing vehicle remain connected once the task is to be transmitted back to the source vehicle.

After the list of the j potential cooperative computing vehicles is finalized, the RSU then sorts them according to their computing available time and selects the cooperative computing vehicle with the lowest computing available time. The task is then offloaded to the selected cooperative computing vehicle.

4.3. ANN-Based Prediction for Cooperative Computing Vehicle Selection

In this paper, we further utilize ANN-based prediction to find cooperative computing vehicles. This is because the CPU of a cooperative computing vehicle must be available once the task is transmitted to it, rather than at the current time. Task transmission takes a certain amount of time, depending on the task size and channel conditions. Hence, this prediction mechanism helps to better evaluate cooperative computing vehicles by taking into account task transmission time. Similarly, this prediction also helps to consider link connectivity between source and cooperative computing vehicles when a task is computed and ready for transmission back to the source vehicle. Thus, instead of using these metrics at the current time, predicted values are used to improve the selection of cooperative computing vehicles. An ANN is a non-linear tool that consists of an input layer and multiple output layers. The main constituent of an ANN is neurons (nodes). The input layer acquires data from an external source, which could be images, data files or audio data, and then the desired output is calculated after those data have been processed through multiple hidden layers of neurons.

4.3.1. Structure of ANN

The fundamental structure of the ANN is shown in Figure 3, where $x_i$ represents the input of the model, which is then multiplied by the weights $w_{ij}$ of neurons i and j of the hidden and output layers, respectively.

The net output at hidden layer j after passing through the activation function is given as follows [38]:

$$y_j=f\left(U_j\right)$$

(6)

$U_j$ is given as the net input at hidden layer j after summing the bias in its value:

$$U_j=\sum _{i=1}^m{x}_i{w}_{ij}+b{}_j$$

(7)

where, in Equation (6), f is the activation function.

4.3.2. Activation Function

In our implementation, we utilize the rectified linear unit (ReLu), which is further defined by:

$$f\left(U\right)=max(0,a)$$

(8)

ReLu activation functions are non-linear and their output is a when the input is positive, otherwise the output is zero. The output at the hidden layer is further passed to the output layer, which has k neurons and is defined as follows:

$$z_k^{\prime }=\sum _{j=1}^h{y}_j{w}_{jk}^{\prime }+b^{\prime }{}_k$$

(9)

In Equation (9), $w_{ij}$ represents the weights of the jth neuron of the hidden layer and the kth neuron of the output layer. Here, $b_k$ is the value of the bias. After passing through the ReLu activation function, the output is given as follows:

$$z_k=f\left(Z_k^{\prime }\right)$$

(10)

4.3.3. Loss Function

The calculated output $z_k$ is then compared to the target output $t_k$, which gives us the error between the target and calculated output states $L_{Nt}$ as follows:

$$L_{Nt}=\frac{1}{Nt}\sum _{k=1}^{Nt}\mathcal{L}(t_k,z_k)$$

(11)

$\mathcal{L}(t_k-z_k)$ is the loss function, which gives us the error between the actual and desired outputs. The most common loss function is the mean square error (MSE), which is further defined as follows:

$${\mathcal{L}}_{Nt}=MSE(t_k,z_k)=\sum _{k=1}^{Nt}{(t_k-z_k)}^2$$

(12)

where $Nt$ is the total number of samples. Furthermore, the output layer gradient is identified as follows:

$${\delta }_k=(t_k-t_k)f^{\prime }\left(z_k^{\prime }\right)$$

(13)

4.3.4. Backpropagation Algorithm

As part of the ANN, we implement backpropagation (BP) using the Adam optimizer. The learning rate is given as $\eta$, whereas the momentum is adaptively changed by the Adam optimizer itself. The stability and convergence of the algorithm depend on the value of $\eta$: the lower the rate, the more stable the network and the slower the convergence. On the contrary, higher rates lead to faster convergence with unstable systems.

The BP algorithm is used to update the weights and biases. The updated weights $w_{jk}^{\prime }$ and biases $b_k^{\prime }$ from the hidden layer to the output layer are given by:

$$\begin{array}{c}\hfill \Delta w_{jk}^{\prime }=\eta {\delta }_k{y}_j\end{array}$$

(14a)

$$\begin{array}{c}\hfill \Delta b_k^{\prime }=\eta {\delta }_k\end{array}$$

(14b)

The gradient error at the hidden layer is specified as follows:

$${\delta }_j=\sum _{k=1}^K{\delta }_k{w}_{jk}^{\prime }{f}^{\prime }\left(z_k^{\prime }\right)$$

(15)

From the input neuron i to the hidden layer neuron j, the updated weights and biases are calculated as follows:

$$\begin{array}{c}\hfill \Delta w_{ij}=\eta {\delta }_j{x}_i\end{array}$$

(16a)

$$\begin{array}{c}\hfill \Delta b_j=\eta {\delta }_j\end{array}$$

(16b)

Algorithm 1 describes the backpropagation algorithm for updating the weights and biases [39]. It consists of two parts: a feed-forward pass and a corresponding backward pass. The forward pass is performed by Equations (6)–(10), whereas the backward pass is calculated by Equations (13)–(16b).

Algorithm 1: Backpropagation algorithm

4.3.5. Adam Optimization

An extension of the classical stochastic gradient descent (SGD) algorithm, called the Adam optimization algorithm, is used to improve the performance of the ANN. The cost and loss functions used in our case are taken from [40] and are given in Equations (11) and (12).

$$\begin{array}{cc}\hfill & \widehat{\nabla L}\left(W,b\right)=\frac{1}{Nt}\sum _{nt\in {\mathcal{S}}_{SGD}}\nabla \mathcal{L}\left(t_k,z_k\left(W,b\right)\right)\hfill \end{array}$$

(17)

A major difference between the Adam algorithm and the SGD algorithm is that the SGD algorithm uses a single learning rate $\eta$ for the whole weight update process. On the other hand, the Adam optimization algorithm uses adaptive independent rates that are computed for different parameters based on the estimation of the first and second moments of the gradient. It is a combination of two algorithms: the adaptive gradient algorithm (AdaGrad) and root mean square propagation (RMSProp) [41]. Therefore, the Adam algorithm has the advantages of both algorithms. Moreover, when the algorithm uses Adam optimization, it applies correction terms with a scaling factor close to one to both the first and the second moments. Algorithm 2 presents the Adam optimization algorithm [39].

4.3.6. Configuration Parameters for the Adam Optimization Algorithm

The following are the configuration parameters for the Adam optimization algorithm that were used for the ANN model training:

• $\eta$ represents the learning rate or the step size;
• ${\gamma }_1$ and ${\gamma }_2$ are the exponential decay rate parameters that are to be initialized close to 1 (such as $0.9$ and $0.9999$, respectively);
• $\epsilon$ is given as a tolerance factor (usually taken as the very small value of ${10}^{-8}$);
• m and v represent the moving averages of the first and second moments of the gradient, while their corresponding corrected biases are further introduced by $\widehat{m}$ and $\widehat{v}$;
• At the end of the algorithm, W and b are the updated adaptive weights and biases.

The Adam optimization algorithm is faster at choosing parameters compared to the traditional SGD algorithm, which ultimately results in quicker convergence. Choosing appropriate initial values for the parameters used in Adam optimization also plays an important role in efficient convergence, given the fact that the problem is non-convex.    

Algorithm 2: Adam optimization algorithm for ANN model training.

4.3.7. Proposed Prediction Model

Our proposed ANN-based prediction model is divided into two parts:

• Link connectivity time prediction: The link connectivity time $T_{i,j}^{LLT}$ between the source vehicle and all potential computing vehicles is predicted in the first part of the model using four inputs ((i) the speed of the source vehicle, (ii) the speed of a potential computing vehicle, (iii) the distance between the source and potential computing vehicles and (iv) channel gain between the vehicles).
• Computation availability time prediction: The computation availability time $T_{ca}$ of potential computing vehicles is predicted in the second part of the model using two inputs ((i) the number of tasks already at the potential computing vehicle and (ii) the size of those tasks).

The developed ANN model was first trained and then used for prediction. Based on the developed ANN model, the proposed technique predicts the values of link connectivity time and computation available time $T_1$ and $T_2$ seconds ahead. The value of $T_1$ is chosen so that the link connectivity between the source vehicle and the computing vehicle remains intact until the task result is transmitted back to the source vehicle. The value of $T_2$ is selected so that the computing vehicle’s CPU is available once the task is transmitted to it from the source vehicle for computation.

5. Performance Evaluation

In this section, we present our performance evaluation of the proposed technique.

5.1. Dataset Generation for ANN Training

The details of the dataset used for training the proposed ANN model are shown in

Table 2. Details of the dataset generated to train the ANN model.

ANN Model	Features Used	Data Range
Computation Available Time	Vehicle speed	30–120 km/h
	Distance between source and computing vehicles	5–100 m
	Channel gain	Rayleigh distribution
Link Connectivity Time	Number of tasks	Poisson distribution
	Task size	0.5 MB–16 MB

. Then, we explain the salient characteristics of the dataset generated to train the ANN model.

• Link connectivity time model: There are three input parameters for the link connectivity time model. In Table 2, we mention the ranges of the values for all features used to generate the dataset. The value of speed is taken from the range of 30–120 km/h, which is generated in our case using a Gaussian random distribution. The second input feature is the distance between the vehicles. This depends on the speeds of the source and potential computing vehicles and the range of the distance is taken as 5–100 m. The last input parameter is the channel gain, which indicates the conditions of the vehicle-to-vehicle channel. The channel gain is generated using complex Gaussian random variables of zero mean, thus providing a Rayleigh fading channel.
• Computation availability model: There are two inputs for the computation availability model. The first input is the number of tasks or requests to offload at a particular time slot t. The Poisson distribution is used to generate the number of tasks, with an average rate of $\lambda$. The second input is the task size, the value of which lies in the range of 0.5 MB–16 MB. This range is used to realistically model the computation availability as at a particular time slot; however, there may be scenarios in which there are fewer tasks but the tasks are larger or more tasks but the tasks are smaller, etc.

5.2. Simulation Parameters

The values of the simulation parameters used are given in

Table 3. Simulation parameters and values used.

Parameter	Value
Task size	0.5 MB–16 MB
$C_b$ of vehicles’ CPUs	500 cycles/bit
$C_b$ of fog node’s CPU	2000 cycles/bit
Frequency C of vehicles’ CPUs	2G cycles/s
Frequency C of fog node’s CPU	8G cycles/s

. All simulations were implemented in MATLAB 2020a software. We use a task size of 0.5 MB–16 MB. The cycles per bit of the vehicles’ CPUs is taken as 500, whereas the fog node processor is considered to be four times better, thus providing $C_b$ of 2000 cycles/bit. The frequencies of the vehicles’ CPUs and the fog node’s CPU are taken as 2G and 8G cycles per second, respectively.

5.3. Performance Metrics

The following four types of error score indicators are used as performance metrics for the evaluation of the ANN prediction model. These include root mean square error (RMSE), mean absolute percentage error (MAPE), mean absolute bias error (MABE) and the coefficient of determination ($R^2$). The following equations describe the mathematical formulae used to evaluate these four types of errors:

$$RMSE=\sqrt{\frac{1}{n}\sum _{i=1}^n(Z_i-Z_i^{\prime }{)}^2}$$

(18)

$$MAPE=\frac{1}{n}\sum _{i=1}^n\frac{|Z_i-Z_i^{\prime }|}{Z_i}\times 100$$

(19)

$$MABE=\sum _{i=1}^n\frac{|Z_i-Z_i^{\prime }|}{n}$$

(20)

$$R^2=1-\frac{{\sum }_{i=1}^n{(Z_i-Z_i^{\prime })}^2}{{\sum }_{i=1}^n{Z}_i}$$

(21)

where n is the total number of dataset samples and $Z_i$ and $Z_i^{\prime }$ are the actual and estimated values, respectively.

RMSE is the first indicator employed to examine model performance, which has a value of zero in the ideal case and positive or non-zero values in non-ideal cases. MAPE is another indicator of the accuracy of ANN models and has low values for accurate models. Similarly, the MABE error score can be used to evaluate the precision of ANN models. Lastly, $R^2$ shows how the fitness of the model and its value lie in the range of $0-1$, with 1 being an indicator of the most accurate models.

5.4. ANN Prediction Model Results

The results of the ANN prediction model are presented in this subsection.

• Training Phase: In the training phase of the ANN model for link connectivity time, the learning rate $\eta$ is taken as 0.01. The value of momentum is adaptively changed by the Adam optimization algorithm and is finally set to 0.9 for optimal results. The number of training samples is taken as 100,000. The number of neurons in the hidden layer is taken as $[30,20,1]$), which provides the best model results in terms of all four evaluation error scores ($RMSE=3.5598$, $MABE=1.9919$, $MAPE=8.6981$ and $R^2=0.9854$).
  In the computation availability time ANN model, the same parameters are used, except that the number of hidden layer neurons is taken as $[20,20,1]$ to provide the best results. The error scores for this model are calculated as $RMSE=1.7857$, $MABE=1.0189$, $MAPE=8.8644$ and $R^2=0.9853$.
• Testing Phase: After describing the details of the training data, the data samples are subjected to the testing phase. The prediction is performed based on both models and the time values $T_1$ and $T_2$ are taken as 1, 2 and 3 s. Generally, $T_1$, which is associated with link connectivity time, is higher than $T_2$ as link connectivity is needed once the task is computed and returned to the source vehicle.

The one-second-ahead prediction is shown in Figure 4, in which the x-axis represents the number of testing samples and the y-axis gives the link connectivity time in seconds. We utilize 20,000 values to test the prediction model. In Figure 4, we show the results of the first 5000 testing samples. It can be seen from the graph that the actual and predicted link connectivity times show similar results, with a high level of accuracy. Accordingly, the prediction results at two seconds and three seconds ahead are also presented in Figure 5 and Figure 6, respectively.

The error scores of the link connectivity model for all predictions are given in

Table 4. Error scores of link connectivity model.

Error	One-Second-Ahead Prediction	Two-Seconds-Ahead Prediction	Three-Seconds-Prediction
RMSE	3.9839	6.0147	7.4742
MABE	2.3066	3.2745	4.4182
$R^2$	0.9838	0.9631	0.9430
MAPE	5.7767	8.8480	11.4301

. The general trend is that the prediction accuracy reduces as the prediction time ahead increases.

For the computation availability model, the predicted and actual results are illustrated in Figure 7, Figure 8 and Figure 9. Similar to the previous model, we use 100,000 samples for training and 20,000 samples for testing. In the graphs, we show the prediction results of the first 5000 samples. It can be seen that the actual and predicted values of computation availability time are quite close in all cases.

Table 5. Error scores of the computation availability model.

Error	One-Second-Ahead Prediction	Two-Seconds-Ahead Prediction	Three-Seconds-Ahead Prediction
RMSE	1.5859	2.5756	3.2739
MABE	0.7570	1.2707	1.6789
$R^2$	0.9746	0.9331	0.8919
MAPE	8.8964	14.8086	18.3649

lists the error scores for the computation availability model. With these results, it can be concluded that the ANN model can accurately predict computation availability time a few seconds ahead of the current time.

5.5. Task Offloading Results

We implement the proposed offloading technique and compare it to three other techniques: the matching-based task offloading technique [30], the knapsack-based task offloading technique [42] and the exhaustive search algorithm. The comparison is conducted using different ratios of vehicles generating the task. In Figure 10, the results show that the proposed task offloading technique computes all tasks within 5 s at a high task workload scenario, i.e., when 90% of vehicles have a computation task. On the other hand, the matching-based and knapsack-based task offloading techniques show inferior results, with a total delay of around 7.8–8 s in the high task workload scenario. Lastly, the exhaustive search technique shows the best results because it tries all combinations and selects the best combination with the lowest task delay. It can be seen that the proposed technique achieves a similar performance to the exhaustive search technique, with a slightly higher task delay.

Figure 11 shows the task delay of the proposed technique in comparison to when CQI-based task offloading is not used and instead, a fixed 50% of the task is offloaded to the fog node. The results show that without using CQI-based offloading, the task delay goes up to 10 s. This is because the channel conditions between the source vehicle and fog node are not considered, thus resulting in lower transmission delay.

Figure 12 shows the task delay when cooperative computing vehicles are either selected without ANN-based prediction or are selected randomly. It can be seen that when cooperative computing vehicles are randomly selected, task delay goes up to 12 s. Without using ANN-based prediction and only making decisions based on the current values of link connectivity time and computation availability time, task delay increases by up to 20% compared to using the proposed technique.

6. Conclusions

In this paper, we present a data-enabled task offloading technique for vehicular networks that utilizes cooperation between fog nodes and other vehicles in the neighborhood. Initially, a certain percentage of a task is offloaded to a nearby fog node, based on channel quality indicator values. Subsequently, the rest of the task is offloaded to a nearby cooperative computing vehicle. The selection of the cooperative computing vehicle is based on factors such as computing availability time and link connectivity time. An ANN-based prediction model is used to find the values of these parameters once the task is offloaded to the cooperative computing vehicle and the result of the task is to be sent back to the source vehicle. Our simulation results highlight the accuracy of the prediction model in terms of computation availability time and link connectivity time. Moreover, we also show that total task delay is reduced when using the proposed technique compared to using other available techniques in the literature. In the future, we aim to work on utilizing more than one cooperative computing vehicle for the further parallel processing of tasks and further improvements in task delay.