Energy Efficient Load-Balancing Mechanism in Integrated IoT–Fog–Cloud Environment

Abstract

The Internet of Things (IoT) and cloud computing have revolutionized the technological era unabatedly. These technologies have impacted our lives to a great extent. The traditional cloud model faces a variety of complications with the colossal growth of IoT and cloud applications, such as network instability, reduced bandwidth, and high latency. Fog computing is utilized to get around these problems, which brings IoT devices and cloud computing closer. Hence, to enhance system, process, and data performance, fog nodes are planted to disperse the load on cloud servers using fog computing, which helps reduce delay time and network traffic. Firstly, in this article, we highlight the various IoT–fog–cloud models for distributing the load uniformly. Secondly, an efficient solution is provided using fog computing for balancing load among fog devices. A performance evaluation of the proposed mechanism with existing techniques shows that the proposed strategy improves performance, energy consumption, throughput, and resource utilization while reducing response time.

1. Introduction

Numerous smart items and devices, including wearable technology, smartphones, and industrial utility parts, have been equipped with sensors in recent years to monitor and gather real-time physical data from their surroundings. For formulating and managing the sensor nodes, a wireless sensor network provides an efficient framework. Due to the heavy traffic generated by the Internet of Things (IoT) nodes, the network along with servers is overloaded and congested. Thereby, an intermediary layer known as the fog layer is introduced as a bridge amidst the IoT devices and cloud, which aids in achieving reduced response delays and time latency. To support the lower layers’ heavy computational workloads, the cloud has introduced the intermediate fog layer to reduce the burden on heavily loaded lower layers.

Numerous complications, which include heterogeneous types of devices, limited bandwidth, restricted computing resources, a wide range of client requirements, operational costs, etc., influence the efficiency of IoT networks [1]. Thereby, an optimal solution is required to address the above-mentioned issues in the network that will significantly enhance the system’s performance. Scheduling and allocation of resources are crucial for managing data centers that help maintain load balancing, proper utilization of resources, and cutting of carbon emissions [2]. Applications and sensor data are frequently sent and processed by data center computers. Due to the IoT applications’ ever-growing resource requirements, it is very difficult to implement them as there is an exponential increase in energy consumption. Subsequently, the performance of the computing node degrades as a result of the massive data transmission and movement of computing devices [3]. Fog computing shifts IoT application computation from cloud platforms to the network’s edge. Various applications of the cloud and IoT, such as healthcare, smart transportation, smart cities, smart homes, smart logistics, environmental monitoring, video surveillance, etc., are implemented to automate daily life processes [4]. Owing to the massive amount of data generated with fast velocity, a fog–cloud environment was needed to handle the computing resources efficiently.

In [5], fog computing is compared with other computing technologies, as represented in Figure 1. Fog computing is a distributed and emerging technology primarily focused on decreasing the latency and data transmission costs to the remote cloud.

Figure 1. Integration of IoT–fog–cloud model.

Problem Statement

The inefficient management of network resources and load balancing accelerates quality-of-service degradation and energy losses. Due to increased traffic overhead on fog gateways, delays have also increased, which cannot be tolerated in real-time applications. High energy usage and load balancing are major areas of research in the fog–cloud environment. To conquer this issue, the IoT–fog–cloud model is introduced in this article by efficiently dispensing the workload among different devices at different levels. Nevertheless, only a restricted amount of information is forwarded to the cloud for further computation, which leads to enhanced bandwidth and reduced latency in the network.

This article highlights the challenges in emergent IoT, the colossal quantity of data produced through sensors, and the trouble in reporting these challenges with available networking and computing models. Thus, this research article presents the need for a new model and architecture called fog computing. Fog computing aids in filling the technological gaps of cloud and IoT models betweenness, viz., quality of service, time latency, and location awareness. The main objective of this article is to proffer a balancing load mechanism in a fog computing environment for a uniform distribution of incoming traffic among available cloud servers or fog devices, considering underloading or overloading of nodes. This improves performance, energy consumption, throughput, and resource utilization while reducing the response time. Without dependence on the cloud, IoT devices send data to a fog server for processing. Thereby, it can efficiently save cloud storage and network bandwidth for important processes and data [6,7,8]. A few current challenges of load balancing are efficiency, fault tolerance improvement, overhead, and the consequences of implementation.

The primary objectives are as follows:

• Investigate the existing literature on the IoT–fog–cloud architecture and models considering energy factors.
• The three significant issues covered in this article are load balancing, energy consumption, and computation delay or latency.
• An energy-efficient and load-balanced mechanism for fog environments, considering available CPU capacity.
• Performance evaluation of the proposed mechanism with existing techniques.

The organization of the rest of the article is as follows: Section 2 inspects the prior studies and analyses their weaknesses and strengths. The methodology of the proposed scheme is illustrated in Section 3. The experimental setup and simulation of this work are described in Section 4. The results and discussion are presented in Section 5. The conclusion of the proposed work is presented in Section 6.

2. Related Work

The authors in [3] proposed resource management and small cell cluster establishment of low complexity for fog computing. This article addressed the load-balancing issues by improving the user’s quality of service (QoS) in fog computing. In Ref. [5], Liu, Y. et al. formulated an optimization problem for resource allocation using a genetic algorithm. The authors have also provided the framework and architecture for resource management, latency reduction, fault tolerance, etc. in fog computing. Authors in [9] developed a tree-based algorithm to uniformly disperse the workload among the fog nodes for fog computing, which progress towards the reduction in energy usage of IoT devices in contrast with the cloud model. The authors in [10] devised a scheme that converges fog computing with an energy-efficient hierarchical routing algorithm in wireless networks. Fog computing has the potential to optimize the available power efficiently. This article also used the ant colony optimization mechanism to find the optimal route for efficient data transmission, leading to energy usage reduction and delay reduction, thus extending the network lifetime. In [11], the authors devised a solution for balancing the load on the Fog of Things platform using SDN. It provides the provision of storing and processing the IoT services on edge devices and optimizing the cloud services. Authors in [12] developed an integrated model of the “Cloud of Things” (CoT), which uses fog computing for dealing with delays and energy consumption efficiently. The authors claimed that the proposed energy-aware allocation strategy saves more energy in comparison to the existing methods. In [13], the authors devised an energy-aware load balancing strategy that proficiently distributes the load among fog nodes. Using the simulation, the authors claimed that the power usage of fog and IoT nodes was curtailed significantly. In [14,15], the authors examined the trade-off between transmission latency and power usage in an IoT–fog–cloud environment. The optimal task allocation problem is formulated to minimize energy consumption with limited service delay. The authors proposed the decomposition of the primal problem into subproblems and solved them individually using optimization techniques to achieve the optimal result. In [16], the authors proposed the utilization of queuing models to investigate the transmission delays, power usage, and cost incurred during offloading tasks in the cloud–fog environment. A multiple-objective strategy is developed to minimize the payment cost, execution latency, and energy usage by finding the optimum probability for offloading and transmitting energy for all nodes. In Ref. [17], Q. Fan et al. devised a strategy for heterogeneous networks to improve green energy utilization and flow level throughput. Similarly, in [18], the authors focused on load balancing for fog environments efficiently and devised a strategy called Dynamic Energy-Efficient Resource Allocation (DEER).

In [19,20,21,22], the authors considered the amalgamation of cloud and fog to minimize the resource cost, viz., bandwidth and link level utilization. The authors proposed an optimized strategy that takes into account bandwidth and server resources and provides efficient solutions for the three-layer fog–cloud model. In [23], the authors developed an IoT-oriented router with load metrics and also designed an algorithm for cascade failure for both local and global routing modes. Extensive experimentation and simulation proved that the local routing mode is more reliable in comparison with the global routing mode. The authors in [24] perform an extensive study of cascading failure in edge-assisted IoT. Real-time data packets, congestion status of nodes, and experimental simulation under varied compression ratios provide an optimal solution to prevent cascading failure. In [8,25], authors devised a mechanism called DEELB to deal with the IoT resource allocation problem, which considers the vast issues of energy utilization, load balancing, and the cost of computing. The experimental results indicate that the proposed mechanism provides an efficient and effective solution for allocating resources dynamically. Kaur, M. et al. suggested a model that implements load balancing at the fog layer to enhance resource utilization. When jobs are initialized in the fog nodes, the scheduling of load takes place, and in fog clusters, load balancing is handled by the local controller [26]. The authors in [27] employed simulation to examine the energy efficiency of two particular routing protocols: the Ad hoc On-demand Distance Vector (AODV) and the Destination Sequence Distance Vector (DSDV). It also contrasted how much power was needed in DSDV and AODV to send the data packets to their destinations. Results showed that AODV was more energy efficient than DSDV because its successful routing activities used less energy.

Various state-of-the-art algorithms mentioned in Table 1 deal with a variety of parameters in cloud and fog computing. As IoT devices are generating colossal amounts of data, it becomes very cumbersome to handle that data at nodes on cloud and fog levels. This article presents a novel approach to resolving this issue by integrating IoT, fog, and cloud in a three-tier structure.

Table 1. Summary of load-balancing techniques used in fog environment.

References	Methodology Adopted	Features/Parameters	Limitation
[3]	Proposed low-complexity techniques for load balancing and cluster formation for fog environment	Quality of experience, network performance, latency	The proposed algorithm is not efficient and works well with large clusters
[5]	A framework for optimized resource allocation is proposed and formulated the optimization problem using a genetic algorithm	Latency, optimized resource allocation, privacy, and fault tolerance	Results are computed using a lower number of nodes
[6]	Presented an algorithm for allocating tasks using an energy-aware policy	Energy consumption, round-trip delay	Dynamic conditions of the network were not taken into account
[9]	Developed TBFC, i.e., tree-based fog computing model	Execution time and total electric energy consumption	Proposed techniques do not consider the imbalanced tree of fog, child nodes, and edge nodes
[10]	Fog computing-based energy-efficient hierarchical routing strategies for WSN are proposed	Network lifetime, packet loss, and energy consumption	Lacks optimal resource allocation, and fog node is assumed to be balanced
[13]	In fog computing, an energy-aware and load-balanced algorithm is suggested to assign tasks to fog nodes.	Energy consumed, network cost, execution time, and load scheduling	Limited fog devices, and performance was not evaluated under different dynamic scenarios
[16]	Proposed the utilization of queuing models to investigate the transmission delays, energy usage, and cost incurred for offloading tasks in the cloud–fog scenarios	Power consumption, latency, and cost	A simulation was performed in the restricted environment
[17]	Devised a strategy for a heterogeneous network to improvise green energy utilization and flow level throughput	Throughput and power consumption	Limited to the extent of architecture
[18]	Focused on efficient load balancing for fog environment and devised the Dynamic Energy-Efficient Resource Allocation strategy	Computational cost, load balancing, and energy consumption	Lack of fault tolerance
[21]	An efficient framework is presented that considers the trade-off of power usage and delay in the integrated cloud–fog computing structure	Power consumption and delay	Optimization is not achieved in a distributed environment
[23]	A dynamic energy-efficient load balancing mechanism is proposed to deal with IoT resource allocation dynamically	Energy utilization, load balancing, and cost of computing	Service migration and security concerns
[25]	A potential mechanism for cascading failure in edge-assisted IoT is proposed	Real-time data packets and link congestion	Varied network configurations with different topologies are not considered

3. Methodology

With the tremendous growth in the field of cloud technologies, load balancing and efficient energy consumption have become very difficult tasks. Many cloud providers are available in the market, which provide various services such as pay-as-you-go with a flexible infrastructure. Two key issues arise in the IoT–fog–cloud model: firstly, the declining performance of fog gateways with continuously increasing fog devices; and secondly, the increased congestion in fog devices and the fog gateway transmission link data that are overly delayed. These issues are the repercussions of the dynamic behavior of the IoT–fog–cloud environment. Therefore, it is important to ponder the dynamic nature of the IoT–fog–cloud structure and develop an efficient algorithm to cater to the abovementioned issues. The following principles are followed while designing and implementing the algorithm for the dynamic IoT–fog–cloud environment:

A.

Fog nodes are prioritized overcloud nodes. When data flows are imbalanced at fog devices or gateways, data will be forwarded to the cloud to utilize cloud nodes.

B.

Cloud nodes will be utilized only when fog nodes are congested or drained of power.

C.

Computational delay and latency, load balancing, and energy usage are computed in the IoT–fog–cloud network.

D.

A few fog nodes or gateways can be deactivated when the computing demand is low to conserve energy.

System Model

Cisco introduced the idea of fog computing in 2014, and it provides the distributed infrastructure for IoT to expand capabilities and computing power to the network’s edge [1]. In the fog model, data is managed and controlled by the end users, such as local clouds. As an example, as represented in Figure 2, there are fog nodes, N IoT nodes, and a central cloud node. Each IoT node generates lots of service requests. The traffic models are as follows: at the IoT node level, M/M/1 [28] queue; at the fog node, M/M/c [29,30] queue; at the cloud node, M/M/∞. Each IoT device forwards the request to the fog node using a wireless medium. If the maximal acceptance rate of the fog node is higher than the request rate, then the fog node will process all the requests. Otherwise, the fog device will send the traffic to the cloud centrally for execution.

Figure 2. Flow chart of the methodology.

i.

Transmission Model

Data transmission rate from IoT to fog nodes as per Shannon’s equation [31] can be described as:

$$C_{i,j}\left(t\right)=Blo{g}_2\left(1+\frac{P_i^c\left(t\right)G_{i,j}\left(t\right)}{W{N}_0}\right)$$

(1)

where $G_{i,j}\left(t\right)$ is the channel gain, $P_i^c$ represents the transmission power, B is the bandwidth, N0 represents the noise, and $C_{i,j}\left(t\right)$ represents the data transmission at time t from I to j. Using the M/M/1 [18], the uplink latency (transmission time and queuing) and average delay can be computed using Equation (2) [32]

$${\tau }_D=\frac{1}{\frac{C_{i,j}\left(t\right)}{{\omega }_i\left(t\right)P_i\left(t\right)}-{\omega }_i\left(t\right){\phi }_i\left(t\right) }$$

(2)

where ${\tau }_D$ represents the transmission delay, ${\omega }_i$ denotes the offloading ratio, and $P_i$ signifies the packet magnitude of ith task. Note that the fixed-size data are transmitted and utilized to find the transmission rate. Consequently, it is not essential to take into account each packet’s length since it does not affect the optimal decision and subsequently the optimal solution.

ii.

Fog device computational delay

Considering the kth fog device with the rate of traffic t_k and s_i service rate [33], the computation latency which includes service time and waiting time $C{D}_k^{fog}$ is

$$C{D}_k^{fog}=\frac{1}{s_i-t_k}$$

(3)

iii.

IoT–Fog System Energy Consumption Model

Overall energy usage [34] in IoT–fog can be expressed as

$$Q_{iot-fog}=\sum _{j=1}^K{Q}_j\left(t\right)+\sum _{i=1}^N{Q}_{i,j}^c \left(t\right)+\sum _{i=1}^N\left(1-{\omega }_i\left(t\right)\right)Q_i \left(t\right)$$

(4)

where $Q_j\left(t\right)$ represents the energy used by the jth fog node that can be computed as $Q_j\left(t\right)=C{D}_k^{fog} \upsilon F_i\left(t\right){)}^3$; $Q_{i,j}^c \left(t\right)$ is the energy required to transfer data from node I to j; K represents the number of IoT nodes; and N represents the set of fog nodes.

iv.

Modeling for Load Balancing in IoT–Fog–Cloud Environment

This segment presents various mechanisms for load balancing in the fog–cloud model. The prime objective of this technique is to improve the usage of present resources by uniformly distributing the tasks among computing nodes, avoiding the underloading and overloading of one node. It also takes care of idle nodes. Using fog computing, a group of fog nodes is responsible for workload distribution among different computing nodes in the cloud model, thereby achieving more reliability in incoming jobs and increasing the capability of present clients.

Balancing uniform load is important in the cloud environment owing to the dynamic number of requests coming from the client for network resources. To minimize the lag, dynamic load balancing is essential to avoid lagging in execution considering the long queue of tasks at the computing node. Architecture balancing load at various layers is shown in Figure 3 for the IoT–fog–cloud model.

Figure 3. IoT–fog–cloud model architecture.

The current Load status of devices is represented in Equation

$$Load\left(D_j\right)=\frac{{\sum }_{n=1}^{N}P\left(t\right)}{t}$$

(5)

where P(t) signifies the job size, and the simulation time is “t”. A total number of tasks N processed at node D_j. The average load at each device is calculated as follows:

$$A_{Loa{d}^i}=\frac{{\sum }_{j=1}^M\left[ R{T}_j\left(N\right)+TET \left(N\right)\right]}{M}$$

(6)

where $R{T}_j$ denotes the remaining time of the node. Fog nodes M presently used at time “i”. Execution time is denoted by TET(N) of all jobs. At the output layer, the balanced workload is predicted for all M fog devices.

Algorithm 1 show the proposed algorithm for load balancing.

Algorithm 1: Proposed Algorithm for Load Balancing

Step 1. PowerStatus = Check_power_status (nodes) Step 2. For fog node from i = 1 to n do Step 3. Calculate the existing load of each fog node using Equation (5) Step 4. Calculate the Power status of each fog node Step 5. The transmission delay and Computational delay of each node are computed using Equations (2) and (3) Step 6. Calculate the Energy consumption of each fog and IoT device Step 7. If (PowerStatus of ith node == Full || intermediate && load_status == LOW) then Step 8. If energy_consumption ≤ Threshold                                 Selected_Node = Ni                    Else Step 9. Find another Node with minimum energy consumption         Else Step 10. Find another node       End       End Function Check_power_status () Data Input: fog nodes, IoT nodes, Cloud nodes Output: node lifetime, Power_Status; Node_lifetime = $\frac{\mathrm{Capacity}\_\mathrm{of}\_\mathrm{node}}{\mathrm{Drain}\mathrm{Rate}}$ For all nodes in the network do If (node_lifetime > 80%) then i Return Power_status = Full Else if (node_lifetime > 40% && node_lifetime < 80%) then i Return Power_status = Intermediate Else i Return Power_status = Low End if End for

4. Experimental Setup for Simulations

The experiments were carried out with Intel and 16 GB of RAM using Ubuntu 16.04 LTS. The simulation Core i5-4210 processor time was set to 1000 s to provide variations in workload to identify the inactive FOG gateways and saturation situation. During simulation, 10 nodes are considered, which are randomly generating the data at 120 tasks per second and a data transmission rate of 2 MB/s.

The simulation was performed with varying parameters for 1200 individual runs to find a stable and feasible result. Various parameters for simulation are detailed in Table 2.

Table 2. Parameter values used for simulation.

Parameter	Values Used for Simulation
Total end devices	50 to 100
Total fog devices (F)	10 to 100
CPU frequency in cloud servers	100 × 109 [cyc/sec]
Total gateway devices (G)	2
The average number of incoming tasks (λi)	50 [tasks/sec]
Maximum channel bandwidth	30 MHz
Total cloud servers (S)	5
CPU frequency in end devices	500 × 106 [cyc/sec]
CPU frequency in fog devices	50 × 109 [cyc/sec]
Processing energy usage	0.5 Joules
The transmission power of end devices	mW

Performance Evaluation

The performance is evaluated to ascertain the efficiency of the proposed technique using the simulation toolkit fogs. Analysis and comparisons are carried out with the existing algorithm EEHFC [10] and LBS [30], considering the following qualitative performance metrics: the usage of energy and response time within the IoT–fog–cloud environment. To evaluate the performance of the proposed technique, the following metrics are calculated and utilized:

i.

Network lifetime: It represents the lifespan of devices in the network. When an average number of devices are not functional, network partitioning occurs [13]. Network lifetime can be computed as follows:

$$Node Lifetime=\frac{Nod{e}^{\prime }s Remaining Energy}{Drain Rate}$$

(7)

ii.

Total energy consumption: It represents the overall power consumed in the IoT–fog–cloud environment. The overall energy [35] usage of all devices can be computed using Equation (4). Due to the increased energy of fog nodes, the suggested technique saves energy and increases network longevity, as shown in Figure 3.

iii.

Average Delay: It consists of both transmission and Computational delay in IoT–fog–cloud operation [36]. It can be calculated using Equations (2) and (3).

$$Average Delay=\frac{ {\tau }_D+C{D}_k^{fog}}{Total No. of devices}$$

(8)

iv.

Response time: It represents the response time of all tasks (T) up to the present interval [37]. The average response time can be computed as follows:

$$ResTime (T_I)=\frac{{\sum }_{d_t^j\in T}ResponseTime\left(d_t^j\right)}{ResponseTime(d_j^{S_e})}$$

(9)

where T is a set of tasks, and d_t is the host device at time t.

5. Results and Discussion

The rigorous performance evaluation of the above-suggested algorithm is carried out based on the above-mentioned parameters, as shown in Table 2, and compared with existing EEHFC and LBS techniques. The network lifetime of all nodes and all links used in the network is computed for the proposed technique and compared with other schemes, as shown in Figure 4. It is observed that the network lifetime of the proposed scheme is enhanced because it considers efficient energy consumption and load balancing among various devices at different levels in the network.

Figure 4. Network Lifetime vs. Traffic Load.

Energy consumption has been optimized for the proposed scheme, as shown in Figure 5, as compared with other existing schemes. This is because loads are balanced across different levels. If fog nodes are processing the requests of IoT devices, then the data traffic is not forwarded to the cloud. Hence, cloud nodes are efficiently utilized. The energy consumption of the proposed EEHFC and LBS techniques is represented in Figure 5. Energy usage is computed with a varying number of devices, from 50 to 500. The energy of the nodes is drained out with an increase in data traffic.

Figure 5. Energy Consumption vs. No. of nodes.

The average delay of various techniques is shown in Figure 6. Delay comprises transmission delay and computational delay at both the fog layer and the cloud layer. The proposed algorithm is focused on achieving load balancing between fog–cloud tiers. Delay is reduced as tasks are offloaded and uploaded from the fog to the cloud layer. It is visible in Figure 6 that the delay is increasing as more and more nodes and data flow through the network.

Figure 6. Average Delay vs. No. of nodes.

The information shown in Figure 7 indicates that response time is reduced with the number of nodes as a result of load balancing. This is due to the deployment of fog devices in the fog layer, which reduces the response time by distributing the load among fog devices and forwarding traffic load to the cloud layer. The response time of the fog node altered as the load on the various fog nodes increased or decreased. The response time variation in many settings demonstrates the performance of the suggested algorithm, and the findings demonstrate that the proposed technique beats competing algorithms in different scenarios.

Figure 7. Response Time vs. No. of nodes.

6. Conclusions

With the colossal increase in IoT device usage, there is a need for an efficient system that can deal with the issues of increased load, energy, and delay as a result of more data traffic and processing. In this article, an integrated model is proposed for IoT–fog–cloud to efficiently use the available resources. A three-tier architecture having IoT devices, fog nodes, fog gateways, and cloud devices is used to achieve uniform load balancing among fog and cloud tiers. A novel algorithm is developed which considers energy usage of nodes, delay, network lifetime, and response time. Concretely, a systematic framework is developed to investigate the energy consumption, load balancing, and delay in an IoT–fog–cloud environment. Using the iFogSim simulator, the proposed algorithm is tested for load balancing in an IoT–fog–cloud environment. The results are presented that show the proposed model is outperforming the existing mechanisms under different scenarios. The proposed algorithm works well for a moderate number of devices., but if the IoT data continues increasing exponentially, it will be difficult to handle. Therefore, in future work, we intend to investigate the IoT–fog–cloud environment with more QoS parameters and with more data traffic at each layer.