An Optimal Task Assignment Strategy in Cloud-Fog Computing Environment

Abstract

With the advent of the Internet of Things era, more and more emerging applications need to provide real-time interactive services. Although cloud computing has many advantages, the massive expansion of the Internet of Things devices and the explosive growth of data may induce network congestion and add network latency. Cloud-fog computing processes some data locally on edge devices to reduce the network delay. This paper investigates the optimal task assignment strategy by considering the execution time and operating costs in a cloud-fog computing environment. Linear transformation techniques are used to solve the nonlinear mathematical programming model of the task assignment problem in cloud-fog computing systems. The proposed method can determine the globally optimal solution for the task assignment problem based on the requirements of the tasks, the processing speed of nodes, and the resource usage cost of nodes in cloud-fog computing systems.

1. Introduction

In the era of the Internet of Things (IoT), many emerging applications need to provide real-time responses and interactions. According to the report by market insights firm IoT Analytics, global IoT device connections are estimated to surpass non-IoT device connections and reach 11.7 billion in 2020 [1]. The International Data Corporation (IDC) predicts that 75% of 55.7 billion devices worldwide will be connected to an IoT platform by 2025. IDC also estimates that the data generated from the IoT devices will grow from 18.3 ZB in 2019 to 73.1 ZB by 2025 [2].

In various industries, such as transportation, oil and gas, manufacturing, mining, and utilities, a short response time plays a vital role in improving the output, boosting service levels, and increasing the safety. The data sensed from the IoT devices often requires a rapid and real-time analysis of the data. Consequently, an appropriate infrastructure must be designed to deal with the rapid growth of the IoT data for making a timely and correct decision during event detection [3]. Cisco [3] listed the main requirements for the processing of the IoT data; a well-designed task assignment strategy can satisfy the following requirements:

• latency decrement
• network bandwidth conservation
• data movement to the best place for processing

Although cloud computing has many advantages, the massive expansion of the IoT devices and the explosive growth of data may induce network congestion and add network latency. Conventional cloud computing architectures that transmit all data from the network edge to the central data center for processing cannot meet all of the above requirements. Transmitting the huge amount of data from the IoT devices to the cloud imposes a significantly heavy burden on network performance. This situation also results in unreliable network latency or uncertain response time for end-users [4,5].

Edge computing has a decentralized architecture that assigns processing tasks to the edge in the network to reduce the network delay. Fog computing transforms network edge devices into parts of a distributed computing architecture to implement IoT applications such as medical and healthcare, building and home automation, traffic control, environmental monitoring, energy management, transportation networks, etc. [3,4]. Compared to pure cloud computing, edge computing and fog computing perform better within the aspects of data transmission speed, privacy and security, limited bandwidths, and data control [6]. Due to the advancements in information technology, conventional network edge devices—for instance, routers, gateways, workstations, and personal computers—have become increasingly powerful in the context of the processing capability, storage space, and communication capability. The resources not only can be utilized by their owners but help to push data handling to the network edge [5].

This paper focuses on the optimal task assignment strategy that minimizes the execution time and operating costs in a cloud-fog computing environment. Nguyen et al. [4] constructed a nonlinear mathematical programming model to treat the task assignment problem in a cloud-fog computing environment for the IoT. The model consists of an objective function that involves a parameter to control the trade-off between task completion time and total cost. They also developed evolutionary algorithms to solve the problem. However, their methods cannot guarantee the global optimality of the obtained solution. This study proposes a method to transform the nonlinear problem into a linear model and then guarantees to find a globally optimal solution of the task assignment problem.

The rest of this paper is organized as follows. Section 2 presents a review of the related research on the optimal task assignment strategy in the cloud-fog computing environment. Section 3 introduces the task assignment problem by considering the execution time and operating costs in the cloud-fog system. The proposed method is described in Section 4. Finally, Section 5 provides the conclusions.

2. Literature Review

Due to the exponential increase of data generated by network devices, the conventional cloud computing architecture cannot meet the level of low latency and quick response required by IoT applications. Therefore, fog computing has received increasing attention in recent years. Cisco first proposed fog computing that can transform network edge devices into parts of a distributed computing infrastructure for supporting IoT applications [3]. Shi et al. [7] investigated the fundamental characteristics of fog computing for healthcare systems. Yi et al. [8] discussed the definition of fog computing and similar concepts, introduced three representative applications, and identified various issues when designing and implementing fog computing systems. Yousefpour et al. [9] developed a fog-node policy that considered queue lengths and various types of requests with different processing times to minimize service delays for IoT nodes. Lee et al. [10] explored the security threats and privacy issues for implementing the IoT in a fog computing environment. Hong et al. [11] proposed an architecture to deploy IoT applications across various devices, from the edge devices to the cloud. Mahmud et al. [12] proposed a taxonomy of the fog computing environment and discussed possible challenges and features.

Cloud-fog computing allows some cloud services to be executed on the edge of the network. How to select the appropriate nodes for the tasks to be processed is critical to the performance of the cloud-fog computing architecture. Deng et al. [13] investigated a workload allocation problem considering power consumption and delay in a cloud-fog computing system. They approximately decomposed the problem into three subproblems and then solved each subproblem by existing optimization techniques. The simulations and numerical results indicated that fog computing can complement cloud computing in bandwidth conservation and transmission latency reduction. Pham and Huh [14] discussed the task scheduling problem in a cloud-fog environment. They developed a heuristic-based algorithm for task scheduling to achieve the balance between the execution time and the monetary cost of cloud resources. Nikoui et al. [15] proposed a cost-aware genetic-based task scheduling algorithm to enhance the cost efficiency for real-time applications in a fog-cloud environment. Guevara and da Fonseca [16] developed task scheduling algorithms based on integer linear programming techniques for multiclass services in cloud-fog computing systems.

Nguyen et al. [4] investigated the main techniques and the improvement criteria of the developed task assignment algorithms for cloud computing or fog computing. However, in the hybrid cloud-fog computing environment, the cloud nodes and fog nodes are different in processing capability and resource usage costs. Therefore, the tasks may not be equally assigned to all nodes [4]. The tasks should be allocated to different nodes according to the requirements of the tasks, the processing speed of nodes, and the resource usage cost of nodes. Since existing methods are not suitable for the hybrid cloud-fog computing architecture, Nguyen et al. [4] constructed a mathematical programming model to investigate the task assignment problem and developed evolutionary algorithms to solve the problem.

3. Proposed Method

Although Nguyen et al. [4] developed evolutionary algorithms to solve the task assignment problem, their methods cannot guarantee the global optimality of the obtained solution. This study transforms the nonlinear model of the task assignment problem into a linear model that is solvable by the general linear programming technique to derive a globally optimal solution.

The optimal task assignment problem in the cloud-fog computing environment discussed in this study, referring to Nguyen et al. [4], can be described as follows. Assume $T_k$ be the kth task, then $n$ independent tasks in $\mathit{T}$ are required to be completed in the system and expressed as follows:

$$\mathit{T}=\{T_1,T_2, T_3,\dots ,T_n\}.$$

(1)

The cloud-fog computing system includes cloud nodes and fog nodes; the nodes of the same type have similar characteristics, such as CPU processing power, CPU usage cost, memory usage cost, and bandwidth usage cost. Typically, the cloud nodes have higher capabilities in computing and storage than the fog nodes, but running the tasks on the cloud nodes must pay higher costs. Assume that $m$ nodes consisting of cloud and fog nodes in a set can be expressed as:

$$\mathit{N}=\{N_1,N_2, N_3,\dots ,N_m\},$$

(2)

where $N_i$ is the ith processing node. Each task $T_k$ will be assigned to one processing node $N_i$, which is represented as $T_k^i$. Each processing node $N_i$ ($i=1,2, 3,\dots ,m$) can be assigned multiple tasks, expressed as:

$${\mathit{N}}_{\mathit{i}}^{\mathit{T}}=\left\{T_x^i,T_y^i, \dots ,T_z^i\right\}.$$

(3)

The task assignment problem considered in this study could be formulated as a node assignment of the tasks in $\mathit{T}$:

$${\mathit{T}}_{}^{\mathrm{node}}=\left\{T_1^a,T_2^b, T_3^c,\dots ,T_n^p\right\}.$$

(4)

The execution time for node $N_i$ to complete all assigned tasks in ${\mathit{N}}_{\mathit{i}}^{\mathit{T}}$ can be expressed as:

$$E\_Time \left(N_i\right) = {\sum }_{T_k^i\in {\mathit{N}}_{\mathit{i}}^{\mathit{T}}}E\_Time\left(T_k^i\right)= \frac{{\sum }_{T_k^i\in {\mathit{N}}_{\mathit{i}}^{\mathit{T}}}L(T_k^i)}{\mathrm{CPUrate}\left(N_i\right)},$$

(5)

where $L\left(T_k^i\right)$ is the number of instructions of task $T_k^i$, and $CPUrate\left(N_i\right)$ is the CPU clock rate of node $N_i$. $E\_Time\left(T_k^i\right)=\frac{L\left(T_k^i\right)}{\mathrm{CPUrate}\left(N_i\right)}$ is the execution time of $T_k$ assigned in node $N_i$.

Assume Timespan is the total time to complete all tasks in $T$. Timespan can be derived by the following formula:

$$Timespan=Ma{x}_{1\le i\le m}E\_Time\left(N_i\right).$$

(6)

Let $Cost(T_k^i$) be a monetary amount that must be paid for executing task $T_k^i$ in node $N_i$, consisting of the processing cost $C_p(T_k^i$), memory usage cost $C_m(T_k^i$), and bandwidth usage cost $C_b(T_k^i$). $Cost(T_k^i$) can be expressed as:

$$Cost\left(T_k^i\right)= C_p\left(T_k^i\right)+ C_m\left(T_k^i\right)+ C_b\left(T_k^i\right).$$

(7)

The above three costs can be defined as:

$$C_p\left(T_k^i\right) = cost\_p_i\times E\_Time\left(T_k^i\right),$$

(8)

$$C_m\left(T_k^i\right) = cost\_m_i\times Memory\left(T_k^i\right),$$

(9)

$$C_b\left(T_k^i\right) = cost\_b_i\times Bandwidth\left(T_k^i\right),$$

(10)

where $cost\_p_i$ is the usage cost of CPU per time unit in node $N_i$, $cost\_m_i$ is the usage cost of memory per data unit in node $N_i$, $Memory\left(T_k^i\right)$ is the memory required by task $T_k^{}$ in node $N_i$, $cost\_b_i$ is the usage cost of bandwidth per data unit, and $Bandwidth\left(T_k^i\right)$ is the amount of bandwidth required by transmitting task $T_k$ to be processed in node $N_i$.

The total cost for all tasks to be completed in a cloud-fog system can be expressed as below:

$$Total\_Cost={\sum }_{T_k^i\in {\mathit{T}}_{}^{\mathrm{node}}}Cost\left(T_k^i\right).$$

(11)

Since the optimal task assignment problem considers the execution time and operating costs, Nguyen et al. [4] used an objective function to compute the trade-off between $Timespan$ and $Total\_Cost$ as follows:

$$\mathrm{Objective}=\mathsf{\alpha }\times Timespan+\left(1-\mathsf{\alpha }\right)\times Total\_Cost,$$

(12)

where $\mathsf{\alpha }\in \left[0,1\right]$ is the trade-off coefficient between the execution time and operating costs. If α > 0.5, the task assignment strategy concentrates on minimizing the execution time with a higher priority than the total operating costs. If α < 0.5, minimizing the total operating costs is more important than the execution time. The value of $\mathsf{\alpha }$ depends on the amount of the budget or the level of the required response time.

Nguyen et al. [4] used evolutionary algorithms to find the optimal trade-off task assignment strategy between the execution time and operating costs. Since the heuristic approaches cannot guarantee the quality of the obtained solution, this study derived the optimal assignment strategy based on the globally optimal solution by a deterministic approach. The original mathematical programming model of the task assignment problem in a cloud-fog system can be expressed as follows [4].

Model OTA1:

$$\mathrm{minimize}\mathsf{\alpha }\times Timespan+\left(1-\mathsf{\alpha }\right)\times Total\_Cost$$

(13)

subject to:

$${\sum }_{i=1}^m{T}_k^i=1, 1\le k\le n,$$

(14)

$$Total\_Cost={\sum }_{k=1}^n{\sum }_{i=1}^m(T_k^i\times Cos{t}_k^i),$$

(15)

$$\begin{gathered} Cos{t}_k^i=cost\_p_i\times \frac{L(T_k^i)}{\mathrm{CPUrate}\left(N_i\right)}+ cost\_m_i\times Memory\left(T_k^i\right) +cost\_b_i\times \\ Bandwidth\left(T_k^i\right), \forall T_k^i\in \mathit{T}, \end{gathered}$$

(16)

$$Timespan=Ma{x}_{1\le i\le m}E\_Time\left(N_i\right),$$

(17)

$$E\_Time\left(N_i\right) = {\sum }_{T_k^i\in {\mathit{N}}_{\mathit{i}}^{\mathit{T}}}E\_Time\left(T_k^i\right)= \frac{{\sum }_{T_k^i\in {\mathit{N}}_{\mathit{i}}^{\mathit{T}}}L(T_k^i)}{\mathrm{CPUrate}\left(N_i\right)},$$

(18)

where $\mathsf{\alpha }$, $L\left(T_k\right)$, $\mathrm{CPUrate}\left(N_i\right)$, $E\_Time\left(T_k^i\right)$, $Memory\left(T_k^i\right)$, $Bandwidth\left(T_k^i\right)$, $cost\_p_i$, $cost\_m_i$, and $cost\_b_i$ are the same as described before. The decision variables are $T_k^i$ and $T_k^i\in \left\{0,1\right\}$. Constraint (14) means that the task $T_k$ must be assigned to only one node for execution.

After linearly expressing the constraint (17) in the above model OTA1, the original model can be transformed as follows.

Model OTA2:

$$\mathrm{minimize}\mathsf{\alpha }\times Timespan+\left(1-\mathsf{\alpha }\right)\times Total\_Cost$$

(19)

subject to:

$${\sum }_{i=1}^m{T}_k^i=1, 1\le k\le n,$$

(20)

$$Total\_Cost={\sum }_{k=1}^n{\sum }_{i=1}^m(T_k^i\times Cos{t}_k^i),$$

(21)

$$\begin{gathered} Cos{t}_k^i=cost\_p_i\times \frac{T_k^i\times L(T_k^i)}{\mathrm{CPUrate}\left(N_i\right)}+cost\_m_i\times Memory\left(T_k^i\right)+cost\_b_i\times \\ Bandwidth\left(T_k^i\right), \forall T_k^i\in \mathit{T}, \end{gathered}$$

(22)

$$E\_Time\left(N_i\right)\le Timespan, \forall i, 1\le i\le m,$$

(23)

$$E\_Time\left(N_i\right) = \frac{{\sum }_{k=1}^n(T_k^i\times L(T_k^i))}{\mathrm{CPUrate}\left(N_i\right)},$$

(24)

$$T_k^i\in \left\{0,1\right\}.$$

(25)

Model OTA2 is a mixed-integer linear model that can be solved by the optimization solver to obtain a globally optimal solution. The obtained solution may be different when the trade-off coefficient $\mathsf{\alpha }$ changes.

4. Numerical Experiments and Results

This study discusses the optimal task assignment problem in a cloud-fog computing environment; several numerical experiments are presented to demonstrate the effectiveness of the proposed method. The experiments were conducted on a Notebook with a 2.6 GHz Intel Core i5-7300 CPU and 24 GB memory. All reformulated models were solved by a mathematical programming solver GUROBI 9.1.1 with default settings.

In a cloud-fog computing environment, each node has its own processing capacity, memory, and bandwidth usage cost. This study randomly generated several problems according to the parameters suggested by Nguyen et al. [4].

Table 1. Characteristics of the nodes in a cloud-fog computing environment.

Parameter	Fog Nodes	Cloud Nodes
CPU rate (MIPS)	[500,1500]	[3000,5000]
CPU usage cost	[0.1,0.4]	[0.7,1.0]
Memory usage cost	[0.01,0.03]	[0.02,0.05]
Bandwidth usage cost	[0.01,0.02]	[0.05,0.1]

lists the characteristics of the nodes used to execute the tasks in a cloud-fog computing environment.

Table 2. Characteristics of the tasks to be assigned.

Property	Value
Number of instructions (109 instructions)	[1,100]
Memory required (MB)	[50,200]
Input file size (MB)	[10,100]
Output file size (MB)	[10,100]

lists the characteristics of the tasks.

In our experiments, $\mathsf{\alpha }$ = 0.5 is adopted, which means that the time and cost have identical priorities in the objective. Three datasets are used in our experiments. Referring to the research of Nguyen et al. [4], datasets 1 includes three cloud nodes and 10 fog nodes. To explore the impact of different numbers of cloud and fog nodes on the solution speed of the proposed method, dataset 2 includes five cloud nodes and 12 fog nodes, and dataset 3 includes seven cloud nodes and 14 fog nodes. Cloud nodes are more powerful for processing tasks, but the cost of using them is higher. In each dataset, 10–50 tasks are assigned to different nodes according to the globally optimal solution of Model OTA2 solved by GUROBI. For each case, ten instances with identical numbers of cloud nodes, fog nodes, and tasks are randomly generated. The average CPU time is the average running time of GUROBI to solve each instance.

As seen in

Table 3. Experimental results of the proposed method for 3 cloud nodes and 10 fog nodes (dataset 1).

Case No.	1	2	3	4	5	6	7	8	9
Number of cloud nodes	3	3	3	3	3	3	3	3	3
Number of fog nodes	10	10	10	10	10	10	10	10	10
Number of tasks	10	15	20	25	30	35	40	45	50
Number of 0-1 variables	130	195	260	325	390	455	520	585	650
Number of continuous variables	15	15	15	15	15	15	15	15	15
Number of constraints	37	42	47	52	57	62	67	72	77
Average $Timespan$ (sec)	40.4057	63.6957	89.3140	99.3824	124.0032	107.3536	186.0245	160.2466	195.3863
Average $Total\_Cost$	145.7769	228.4093	266.5487	386.4935	498.4282	561.9562	607.3436	673.5105	764.3977
Average CPU time	0.2191	1.1957	12.0210	46.0756	102.5049	414.2663	580.9763	590.1869	677.3602

,

Table 4. Experimental results of the proposed method for 5 cloud nodes and 12 fog nodes (dataset 2).

Case No.	10	11	12	13	14	15	16	17	18
Number of cloud nodes	5	5	5	5	5	5	5	5	5
Number of fog nodes	12	12	12	12	12	12	12	12	12
Number of tasks	10	15	20	25	30	35	40	45	50
Number of 0-1 variables	170	255	340	425	510	595	680	765	850
Number of continuous variables	19	19	19	19	19	19	19	19	19
Number of constraints	45	50	55	60	65	70	75	80	85
Average $Timespan$ (sec)	48.9281	46.6694	59.0551	81.3217	101.6427	124.4561	141.8461	166.3881	214.1368
Average $Total\_Cost$	142.4031	239.3706	239.2414	354.4158	442.8219	535.4207	596.2381	691.7541	760.2561
Average CPU time	0.3900	1.3135	12.6975	83.7108	149.1998	453.4950	665.6732	721.8558	844.8545

and

Table 5. Experimental results of the proposed method for 7 cloud nodes and 14 fog nodes (dataset 3).

Case No.	19	20	21	22	23	24	25	26	27
Number of cloud nodes	7	7	7	7	7	7	7	7	7
Number of fog nodes	14	14	14	14	14	14	14	14	14
Number of tasks	10	15	20	25	30	35	40	45	50
Number of 0-1 variables	210	315	420	525	630	735	840	945	1050
Number of continuous variables	23	23	23	23	23	23	23	23	23
Number of constraints	53	58	63	68	73	78	83	88	93
Average $Timespan$ (sec)	45.4530	60.9926	79.7936	91.4356	115.0861	103.8784	130.1187	130.7363	164.7988
Average $Total\_Cost$	125.9765	195.1031	270.6764	324.1400	421.4838	494.4605	609.9551	679.6400	729.3251
Average CPU time	0.4890	1.3852	119.1511	148.9607	470.8410	679.0558	706.5134	887.7305	1157.8949

, the average CPU time increases as the number of tasks increases under identical numbers of cloud nodes and fog nodes. For small cases, the results can be obtained within several seconds. Comparing the average CPU time for solving the case with the same number of tasks in the three datasets, the difference is more significant as the number of cloud nodes and fog nodes increases. Since the number of cloud nodes, fog nodes, and tasks determines the number of binary variables in Model OTA2, more cloud nodes, fog nodes, or tasks results in more CPU time for solving the task assignment problem. Since Model OTA2 involves an SOS1 constraint, the technique for treating the SOS1 constraint with fewer binary variables can be considered to improve the computational efficiency of the large-scale task assignment problems in a cloud-fog computing environment.

5. Conclusions

In the era of IoT, how to improve the quality of service in IoT networks becomes a challenging problem. Since conventional cloud computing architectures do not meet the requirements of the IoT applications, edge computing and fog computing have attracted increasing attention from the industrial and academic sectors in recent years. Although evolutionary algorithms can solve the task assignment problem with hundreds of tasks in the cloud-fog system, the quality of the obtained solution cannot be guaranteed. This study developed a linearization method to solve the nonlinear task assignment problem. Therefore, the global optimality of the obtained solution can be guaranteed by using the proposed deterministic optimization approach. This proposed method can allocate tasks to different cloud nodes or fog nodes based on the requirements of the tasks, the processing speed of nodes, and the resource usage cost of nodes in a cloud-fog system.

Although the deterministic method can find a global optimum, the limitation of the proposed approach is that the computational complexity grows rapidly as the problem size increases. More investigation and research will be required to develop an efficient approach for solving the task assignment problem in a cloud-fog system.