Received: 2 August 2016
Revised: 27 May 2017
Accepted: 16 July 2017
DOI: 10.1002/dac.3394
RESEARCH ARTICLE
A genetic algorithm‐based task scheduling for cloud resource crowd‐funding model Nan Zhang
| Xiaolong Yang | Min Zhang | Yan Sun | Keping Long
School of Computer & Communication Engineering, University of Science and Technology Beijing, Beijing, China Correspondence Xiaolong Yang, School of Computer & Communication Engineering, University of Science and Technology Beijing, Beijing, China. Email:
[email protected] Funding information National Natural Science Foundation of China, Grant/Award Number: 61671057
Summary With the rapid development of cloud computing, the number of cloud users is growing exponentially. Data centers have come under great pressure, and the problem of power consumption has become increasingly prominent. However, many idle resources that are geographically distributed in the network can be used as resource providers for cloud tasks. These distributed resources may not be able to support the resource‐intensive applications alone because of their limited capacity; however, the capacity will be considerably increased if they can cooperate with each other and share resources. Therefore, in this paper, a new resource‐providing model called “crowd‐funding” is proposed. In the crowd‐funding model, idle resources can be collected to form a virtual resource pool for providing cloud services. Based on this model, a new task scheduling algorithm is proposed, RC‐GA (genetic algorithm for task scheduling based on a resource crowd‐funding model). For crowd‐funding, the resources come from different heterogeneous devices, so the resource stability should be considered different. The scheduling targets of the RC‐GA are designed to increase the stability of task execution and reduce power consumption at the same time. In addition, to reduce random errors in the evolution process, the roulette wheel selection operator of the genetic algorithm is improved. The experiment shows that the RC‐GA can achieve good results. KEYWORDS cloud computing, genetic algorithm, power saving, task scheduling
1 | INTRODUCTION Cloud computing is an emerging technology that has drawn much attention in recent years. In traditional cloud computing, a data center, operating as the resource provider, performs hardware maintenance, manages task execution and network traffic,1 and conducts other related tasks. However, the power consumption in data centers seriously increases operational costs,1–8 as has been gradually revealed by the rapid development of cloud computing technology. Int J Commun Syst. 2017;e3394. https://doi.org/10.1002/dac.3394
Therefore, in this paper, we build a model based on resource crowd‐funding, which can aggregate the geographically distributed devices with idle resources and use those resources to provide cloud services. In crowd‐funding, all types of equipment can join the resource pool that can provide idle resources. This model is more flexible and supplements the traditional resource‐providing mode. In addition, an efficient task‐scheduling strategy is important to lower power costs. Therefore, it is necessary to design a task‐scheduling algorithm to reduce the total power consumption in the crowd‐funding system. In
wileyonlinelibrary.com/journal/dac
Copyright © 2017 John Wiley & Sons, Ltd.
1 of 10
2 of 10
crowd‐funding, the stabilities of various resources differ because they may come from different devices and belong to different private owners. Therefore, the stability of task execution should be considered when scheduling tasks in the crowd‐funding system. The main issue solved in this paper is scheduling tasks reasonably with the objectives of reducing power consumption and increasing stability. The main contributions of this paper are as follows: • We propose a new resource‐providing model in which the idle resource owners distributed in the network can cooperate with each other and share their resources to provide cloud services. • Under the new resource‐providing model, we present a task‐scheduling strategy based on a genetic algorithm to decrease power consumption and increase the stability of task execution. • We improve the roulette‐wheel‐selection operator of the genetic algorithm to reduce random errors in the evolutionary process. Below, we put forward the crowd‐funding model and present the problem to be solved, introduce our proposed task scheduling method based on genetic algorithm, and provide the simulation results.
ZHANG
ET AL.
In addition, effective task scheduling is essential for obtaining high performance in the cloud environment.13 The authors in Quan et al2 propose a low‐power scheduling algorithm energy‐considered min‐min, but this algorithm may reduce task execution efficiency. An energy‐ saving resource allocation algorithm is presented by migrating applications with high load to a new multicore server and migrating the applications with low load to old single‐core servers.3 Furthermore, the authors in Lee and Zomaya4 put forward 2 energy‐conscious task consolidation heuristics, in which the energy consumption for executing the task is explicitly or implicitly minimized. The linear predicting method and flat period reservation‐ reduced method are used to obtain useful information from the resource use log and to make the M/M/1 queuing theory predicting method less energy‐consuming.6 However, these works are based on the traditional cloud resource‐providing model, whose energy consumption is centralized in data centers. Sharifi et al14 claim that the more decentralized a system is, the less energy is consumed. The high energy consumption of relatively concentrated large servers should be converted to the low energy consumption of the relatively small devices that are widely distributed in the network.
3 | M OD E L DE S I G N 2 | RELATED WORKS Resource sharing is not a new concept. Peer‐to‐peer (P2P) architectures and systems are characterized by resource sharing and direct access between peer computers, rather than through a centralized server.9 However, the key point of P2P is that it is a P2P relationship among devices. The devices in a P2P network can be both a resource provider and a resource user. In addition, sharing among local devices in fog computing can address the problems of unreliable latency and the lack of mobility support in cloud computing.10 The authors in Mehta et al11 propose a “crowd‐cloud” architecture by integrating the sensing and processing capabilities of the dynamic mobile cloud, which can minimize the overall energy consumption and efficiently use the available resources. In addition, the concept of a “local crowd” is proposed, which can realize a lower delay of offloading data than can be realized from a remote cloud.12 This paper considers a resource‐sharing model among various devices in a network to be the resource provider of cloud services. The resource providers of fog computing are always considered the small local devices on the edge of the network or various intelligent routers. However, in our model, all kinds of resource owners in the network (even a data center) that have idle resources could be considered a participator.
In this section, we introduce the new resource crowd‐ funding model, and we describe the scheduling goals and related calculation models.
3.1 | Design of the crowd‐funding model Recently, many idle devices are distributed in networks, which causes the grave waste of resources. In the paper, the spare resources within the distributed network of devices are defined as idle resources. Furthermore, we consider that these resources will be continuously idle in a task cycle. As shown in Figure 1, crowd funding is a new resource provision model that makes the idle resources cooperate with each other and form an intuitive virtual resource pool. In this system, the idle resources can produce revenue according to their contributions by supporting the cloud services. Therefore, crowd‐funding can be defined as “cooperating” or “sharing” to create benefit. The crowd‐funding model can relieve the pressure of traditional data centers and make the most of the idle resources in a network. However, the following significant difference exists between the resource crowd‐funding model and the traditional data center model: The resources in the resource crowd‐funding model belong
ZHANG
ET AL.
FIGURE 1
3 of 10
Resource crowd‐funding model
to many geographically distributed devices. These devices may leave the pool or break down with different probabilities, so it is not easy to ensure the stability of the execution environment. Therefore, for a crowd‐funding system, a reasonable task‐scheduling method is necessary to reduce the waste of resources and improve the quality of task execution.
requests, realizing task scheduling, and recording the resource performance parameters. In the resource pool, we assume that the number of available resource devices is n, and the set of resource device is described by R = {R1, R2 … Rj…, Rn}. In addition, the number of tasks is m, and the task set is expressed as T = {T1, T2 … T i…, Tm}. In this paper, to address the issue
3.2 | Description of task scheduling In crowd‐funding systems, all kinds of devices can participate in the resource pool if they have idle resources. For some resource owners, their resource capacities may be too limited to support some resource‐intensive mobile applications alone. To meet the resource demands of mobile applications, we consider the cooperation among resources as shown in Figure 2. A reasonable task‐scheduling method can effectively save the total power consumption of the resource pool by allocating tasks to the appropriate resources and shutting down temporarily unused resources. Given the diversity of resource devices, the resource stability should be considered when scheduling tasks. From the devices in the crowd‐funding system, a manager should be elected according to the network environment, CPU performance, etc. The manager is used for managing tasks
FIGURE 2
Task‐scheduling diagram
4 of 10
ZHANG
of task scheduling, we allocate appropriate resources for these tasks based on the crowd‐funding model, as shown in Figure 2. Two scheduling targets are designed as follows: 1. Reduce the total power consumption generated by executing tasks. 2. Improve the overall stability of task execution. To state the question clearly, the necessary symbols are defined in Table 1.
3.2.1 | Calculation model for power consumption
1; if T i is allocated on Rj ; 0;
otherwise:
(1)
Therefore, the number of tasks allocated for resource Rj m should be calculated as TN j ¼ ∑i¼1 li; j . If li , j = 1, the corresponding processing rate fi , j (ie, the processing rate of T i on Rj) may be adaptively scaled at run‐time with DVFS techniques.15 fi , j may assume values over the interval [0, ], where f max is the maximum allowed processing rate f max j j of Rj. According to previous research,16,17 the processor use function corresponding to T i can be expressed accord 2 f i; j . Therefore, the procesing to the processing rate as f max j !2 m ∑i¼1 li; j × f i; j sor use of Rj should be expressed as uj ¼ . f max j According to an experiment conducted by Fan et al, one empirical power model is proposed based on processor use.18 The power model in Dayarathna et al18 can be used for calculating the power consumption of Rj as follows: POW j ¼ ðPOW max ð jÞ − POW idle ð jÞÞ 2uj − uj r þ POW idle ð jÞ; TABLE 1
where r is a calibration parameter that minimizes the square error that needs to be obtained experimentally.18 In addition, POWidle(j) is the average power value when Rj is idle, and POWmax(j) is the average power value when Rj is fully used. According to the power consumption of every resource device, the total power consumption can be calculated as follows: POW ¼ ∑ j POW j :
(3)
3.2.2 | Calculation model for stability
In this paper, li , j represents the following condition of task scheduling: li; j ¼
ET AL.
In crowd‐funding, the resource pool is integrated using many resource devices that belong to different owners, and nodes may leave the pool or break down arbitrarily and selfishly. To ensure the smooth implementation of tasks, node reliability should be considered. The reliability of resource Rj is expressed by Pj, which is defined as follows: • Pj is the probability that Rj will not leave and will not break down within the unit time T. The total completion time of tasks executing on CT j resource Rj is expressed as CTj. Therefore, Pj T should be the probability of completing the assigned tasks on Rj. For example, assume that the unit time T is 5 seconds and that the execution time is 10 seconds. If the reliability of node Rj is 0.95, the probability that tasks can be completed smoothly on Rj should be 10 ð0:95Þ 5 ¼ 0:95 0:95. Then, the stability of task execution is the overall stability of all resources, which can be expressed as follows: CT j n ST ¼ ∏j¼1 Pj T :
(4)
(2)
Parameter definitions
Symbol Description Ti
The ith task in the task set
Rj
The jth resource device in the resource set
Xk
The kth individual in the current population
Gj
The jth gene in the current individual
CT i , j
The completion time of T i on Rj
RET i
The required completion time of T i
TNj
The task number allocated for resource Rj, ranging [1,m]
uj
The processor use of Rj
3.2.3 | Constraint condition First, if li , j = 1, the task T i is allocated on resource Rj. Assuming that FLi , j is the number of instructions of T i assigned on Rj, then CT i; j ¼
FLi; j f i; j
should be the completion
time of T i on Rj. To ensure that every task is completed in the required time, one constraint can be formalized as in Equation 5, where RET i is the required completion time of T i. Second, the tasks allocated on the same resource will share the processing capacity of the resource, so the sum of processing rate should meet the relationship in Equation 6. CT i; j ≤ RET i ;
(5)
ZHANG
ET AL.
5 of 10
TN
∑i¼1j f i; j ≤ f max : j
(6)
4 | RC ‐GA ALGOR ITHM To realize the optimized scheduling between resources and tasks, we used an improved genetic algorithm as the scheduling algorithm.19-21 The improved algorithm is referred to as the RC‐GA (genetic algorithm for task scheduling based on a resource crowd‐funding model). The algorithm flowchart21 is shown in Figure 3, and the fitness function design is based on power consumption and the stability of task execution.
4.1 | Fitness function In a genetic algorithm, the fitness function evaluates the superiority of individuals and then decides the evolution
of the next generations. In this paper, we consider the following 2 standards to design the fitness function: total power consumption and overall stability of task execution. For a genetic algorithm, as the fitness value increases, the individual adaptability also increases. Two task‐scheduling targets have been proposed in this paper: decreasing power consumption and increasing reliability. To achieve uniform measurement between the two targets, the power consumption and the stability should be normalized. In this paper, we use the simple additive weighting technique, which has been widely used for performing multiple dimension computations.21 A decrease in power consumption will increase the individual fitness values, so its normalization formulations are expressed as Equation 7. An increase in stability will increase the individual fitness values, so its normalization formulations are expressed as Equation 8.
8 < maxPOW −POW ðX k Þ ; maxPOW −minPOW ≠ 0 − ; f− ð X Þ ¼ f ð POW Þ ¼ maxPOW −minPOW k 1 1 : 1 ; maxPOW −minPOW ¼ 0
FIGURE 3
Algorithm flowchart
(7)
6 of 10
ZHANG
8 < ST ðC k Þ− min ST ; þ fþ ð X Þ ¼ f ð ST Þ ¼ max ST− min ST k 2 2 : 1 ;
To achieve the two targets of task scheduling at the same time, f1 and f2 are integrated to create an overall function. The overall fitness function F(Xk) can be described as follows: þ F ðX k Þ ¼ C 1 f − 1 ðX k Þ þ C 2 f 2 ðX k Þ − ¼ C1 f 1 ðPOW Þ þ C2 f þ 2 ðST Þ;
4.2 | Encoding and initialization The individual length is designed as the number of tasks, and every individual is taken as a solution of task‐ resource scheduling. Therefore, one gene corresponds to one task, and every gene is composed of its corresponding resource IDs assigned for this task as Figure 4 shows. There are the following 3 kinds of task‐resource scheduling modes: (1) one resource corresponds to one task, (2) one resource corresponds to multiple tasks, and (3) multiple resources correspond to one task. For example, an individual is encoded as {"6", "n", "2, 8", … , "1", "6" },which can be explained as follows: T1 and T n are assigned for R6, T2 is assigned for Rn, T3 is assigned for R2 and R8, and T n − 1 is assigned for R1. The population size is set as M, and the generation of an initial population can be described as the process of creating M individuals randomly.
4.3 | Selection operator The selection operator is designed to select the excellent individuals from the current population and generate descendants as the parents. In this paper, we would like to leave individuals with high fitness values to the next generation in a large probability. The roulette wheel selection operator is simple and practical, but it tends to make random errors and result in the excellent individuals losing the opportunity of being left to the next generation.
Individual composition
maxST−minST ¼ 0
:
(8)
Therefore, we put forward an improved algorithm based on roulette wheel selection operator.Detailed process: If the parent population is Z = {X1, X2,…, Xk, … , XM}, and the fitness value of every individual is F(Xk), the detailed process of our selection operator can be described as follows:
(9)
where C1 and C2 can be explained as the preference for saving power and improving stability.
FIGURE 4
maxST−minST ≠ 0
ET AL.
1. Sort all the individuals according to their fitness values, and the populations after sorting are expressed as Z′ = {Y1, Y2,…, Yk, … , YM} , F(Yk − 1) > F(Yk) > F(Yk + 1). 2. Calculate the average fitness value of Z′, represented as AF: M
AF ¼
∑k¼1 F ðY k Þ : M
(10)
3. Divide Z′into 2 parts according to individuals0 fitness values: Z ′1 and Z ′2 . The fitness value of individuals in Z ′1 is greater than AF, and that in Z ′2 is less than AF. 4. Select the individuals from Z ′1 and Z ′2 , respectively, using the roulette selection operator. Therefore, Z ′1 ensures that better individuals have a higher chance to be chosen, and Z ′2 is used for maintaining the population diversity.
4.4 | Crossover operator and mutation operator Crossover operator is used for choosing some pairs of matching genomes and combining them to generate offspring. As shown in Figure 5A, the parent genomes are divided into 2 parts by a cut‐off point, and their tail parts are then exchanged. To ensure the individuals with high fitness values not to be damaged and those with low fitness values have more chances to evolve, the probability that an individual will be chosen for crossover is computed as follows: 8 ′ > < k −ðk 1 −k 2 Þ F −AF F ′ ≥ AF; 1 (11) Pc ¼ F max − AF > : ′ k2 F < AF: Mutation operator is used for avoiding local optimum and is applied to change some genes of offspring as shown in Figure 5B. Similarly, to make the superior individuals
ZHANG
ET AL.
FIGURE 5
7 of 10
Examples for crossover and mutation
have fewer chances to be changed and the inferior ones have more chances to evolve, the probability that an individual will be chosen for mutation is computed as follows: 8 < k −ðk3 −k4 ÞðF−AF Þ 3 Pm ¼ F max −AF : k4
F ≥ AF;
TABLE 2 Resource and task parameters Parameter
Value range
Number of resources in resource pool
[50,200]
Instructions per tasks Maximum resource calculation ability
(12)
F < AF;
where Fmax is the maximum fitness value of the current population. F′ is the larger one of 2 crossover individuals0 fitness values, and F is the fitness value of mutation individual. k1 and k2 are the minimum value and maximal value of crossover probability. k3 and k4 are the minimum value and maximal value of mutation probability.
5 | S I M U L A TI O N A N D EVALUATION In this section, we describe the executed experiments and compare the proposed algorithm with existing methods.
5.1 | Simulation setup The crowd‐funding system, tasks, resources, and various related parameters are described in Table 2. In addition, the parameters used for the genetic algorithm are described in Table 3, and the convergent criterion was found to be that the best fitness value would not improve over the last 20 iterations.22 The calculation ability of resources can be described as the number of instructions that processors can execute per second. The number of
5, 10*10^9 instr f max j
1,2*10^9 instr/sec
Processing rate of T i on Rj, fi , j
[0, 0.6*10^9] instr/sec
Resource stability
[0.8, 0.999]
Required task completion time
[20,30]s
TABLE 3 Genetic algorithm parameters Parameter Description
Value
M
Population sizes
50
k1
Minimum value of crossover probability
0.58
k2
Maximal value of crossover probability
0.86
k3
Minimum value of mutation probability
0.05
k4
Maximal value of mutation probability
0.096
C1
Preference for power consumption
0.2,0.5,0.8
C2
Preference for stability
0.8,0.5,0.2
instructions per task, the required completion time per task, and the stability of resources are generated randomly within certain ranges, as shown in Table 2. According to certain literature,18 the value of r is set as 1.4.
8 of 10
ZHANG
Furthermore, to evaluate the performance of our algorithm, the following approaches were used:
power consumption is set at 0.8 and the preference for stability is set at 0.2, which means that the scheduling results of the RC‐GA realize greater power savings than improved stability. The power consumption with the RC‐GA is always less than that with the NSGA‐II, as is shown in Figure 7A. In Figure 7B, the preference for power consumption is set at 0.2 and the preference for stability is set at 0.8; the result shows that the performance on overall stability with the RC‐GA is better than the performance with the NSGA‐II. However, when the preference for power consumption is equal to the preference for stability, the selecting weights of the RC‐GA for the two objectives are the same. In this situation, the performances of the RC‐GA and the NSGA‐II are indistinguishable, as shown in Figure 7C,D. Although NSGA‐II can realize multi‐objective optimization, it cannot realize the preference adjustment for each objective like the RC‐GA. In addition, the calculation process of the NSGA‐II is more complex than that of the RC‐GA. For the RC‐GA, its computation complexity is O(M2). However, the computation complexity of the NSGA‐II is O(lM2)(l is the number of objective functions, which is 2 in our paper).
• Random: It randomly selects one solution for task scheduling. • RC‐GA: It is our algorithm for task scheduling based on the resource crowd‐funding model. • IGA: It is a method for task scheduling aimed at saving energy using classical genetic algorithm. • NSGA II: Nondominated sorting genetic algorithm 2 is an algorithm23 for solving multi‐objective optimization problems that is used for allocating resources in data centers in Portaluri et al.1
5.2 | Simulation results i Figure 6A,B shows the performance of the RC‐GA on power consumption and stability when varying the number of tasks. As shown in Figure 6A, the total power consumption increases as the number of tasks grows. For the RC‐GA, the more resources there are in the system, the more scheduling solutions are available. Therefore, the RC‐GA can select better solutions (with low power consumption and high stability) to execute the tasks. The total power consumption will be lower and the overall stability of task execution will be higher when there are more resource provisions. According to Equation 4, the overall stability of task execution will be lower with the increase of execution time. In general, the execution time will increase with the task scale. Therefore, the stabilities of task execution with RC‐GA decrease with the increasing number of tasks, as shown in Figure 6B. ii Figure 7 shows the performance comparison of power consumption and stability among the RC‐GA, NSGA‐ II, and Random methods. In the experiments, we analyze the solutions, considering 2 objectives separately, to evaluate the two edges of the obtained Pareto front of the NSGA‐II. In Figure 7A, the preference for
FIGURE 6
ET AL.
In addition, no matter how many resources in the system and how many tasks need to be allocated, the Random method performance is always relatively poor. iii Experiments in this section are designed to evaluate the effect of the RC‐GA on execution time performance. In this paper, the selection operator is improved to reduce random errors. Therefore, the convergence speed of the RC‐GA should be faster than the classical genetic algorithm. The result shows that the execution times of the RC‐GA are always less than they are with IGA (which is based on a classical genetic algorithm) whether the task scale is small or large; the effects are more evident with large‐ scale tasks, as shown in Figure 8.
Performance of RC‐GA on power consumption and stability
ZHANG
ET AL.
9 of 10
FIGURE 7 Comparison among RC‐GA, NSGA‐II and random A, C1 = 0.8, C2 = 0.2; B, C1 = 0.2, C2 = 0.8; C, C1 = 0.5, C2 = 0.5; and D, C1 = 0.5, C2 = 0.5
FIGURE 8
Comparison for execution time
6 | CONCLUSIONS In this paper, we proposed a resource crowd‐funding model to provide resources for cloud services; our model may be more flexible than the traditional data center model. On the basis of this new model, we developed a task scheduling method to save energy and ensure the stability of task execution using a genetic algorithm. For the resource crowd‐funding model, an effective incentive is needed to encourage idle resources to join the resource pool, and we will consider this issue in our upcoming work.
addition, we thank LetPub for its linguistic assistance during the preparation of this manuscript.
ORCID Nan Zhang
http://orcid.org/0000-0002-5802-1889
RE FER EN CES
A C K N O WL E D G E M E N T
1. Portaluri G, Giordano S, Kliazovich D, Dorronsoro B. A power efficient genetic algorithm for resource allocation in cloud computing data centers[C]//cloud networking (CloudNet), 2014 IEEE 3rd International Conference on. IEEE, 2014: 58‐63.
This research was supported by National Basic Research Program of China (Grant 2012CB315905) and National High‐tech R&D Program (Grant 2013AA01A209). In
2. Quan DM, Meezza F, Sannenli D, Giafreda R. T‐Alloc: a practical energy efficient resource allocation algorithm for traditional data centers [J]. Futur Gener Comput Syst. 2012;28(5):791‐800.
10 of 10
ZHANG
ET AL.
3. Beloglazov A, Abawajy J, Buyya R. Energy‐aware resource allocation heuristics for efficient management of data centers for cloud computing [J]. Futur Gener Comput Syst. 2012;28(5):755‐768.
15. Shojafar M, Cordeschi N, Baccarelli E. Energy‐efficient adaptive resource management for real‐time vehicular cloud services[J]. IEEE Transactions on Cloud computing, 2016.
4. Lee YC, Zomaya AY. Energy efficient utilization of resources in cloud computing systems [J]. J Supercomput. 2012;60(2):268‐280.
16. Horvath T, Abdelzaher T, Skadron K, Liu X. Dynamic voltage scaling in multitier web servers with end‐to‐end delay control[J]. IEEE Trans Comput. 2007;56(4):444‐458.
5. Kar I, Das H. Energy aware task scheduling using genetic algorithm in cloud datacenters. Int J Comput Sci Inf Technol Res. 2016;106‐111. 6. Shi Y, Jiang X, Ye K. An energy‐efficient scheme for cloud resource provisioning based on CloudSim[C]//2011 IEEE international conference on cluster computing. IEEE, 2011: 595‐599. 7. Beloglazov A, Buyya R. Energy efficient resource management in virtualized cloud data centers[C]//proceedings of the 2010 10th IEEE/ACM international conference on cluster, cloud and grid computing. IEEE Computer Society, 2010: 826‐831.
17. Shojafar M, Cordeschi N, Abawajy JH, Baccarelli E. Adaptive energy‐efficient qos‐aware scheduling algorithm for tcp/ip mobile cloud[C]//Globecom workshops (GC Wkshps), 2015 IEEE. IEEE, 2015: 1‐6. 18. Dayarathna M, Wen Y, Fan R. Data center energy consumption modeling: a survey. IEEE Commun Surv Tut. 2016;18(1):732‐794. 19. Cui YF, Li XM, Dong KM, Zhu JL. Cloud computing resource scheduling method research based on improved genetic algorithm [J]. Adv Mater Res. 2011;271:552‐557.
8. Dabbagh M, Hamdaoui B, Guizani M, Rayes A. Energy‐efficient cloud resource management[C]//INFOCOM workshops. 2014: 386‐391.
20. Gu J, Hu J, Zhao T, Sun G. A new resource scheduling strategy based on genetic algorithm in cloud computing environment [J]. J Comput. 2012;7(1):42‐52.
9. Androutsellis‐Theotokis S. A survey of peer‐to‐peer file sharing technologies[J]. 2002.
21. Wang C, Li Z. Parametric analysis for adaptive computation offloading[C]//ACM SIGPLAN notices. ACM. 2004;39(6):119‐130.
10. Yi S, Li C, Li Q. A survey of fog computing: concepts, applications and issues[C]//proceedings of the 2015 workshop on mobile big data. ACM, 2015: 37‐42. 11. Mehta V, Shaikh Z, Kaza K, Mustafa HD, Merchant SN. A crowd‐cloud architecture for big data analytics [C]//communication (NCC), 2016 twenty second National Conference on. IEEE, 2016: 1‐6. 12. Song C, Liu M, Dai X. Remote cloud or local crowd: communicating and sharing the crowdsensing data[C]//big data and cloud computing (BDCloud), 2015 IEEE fifth international conference on. IEEE, 2015: 293‐297. 13. Guo F, Yu L, Tian S, Yu J. A workflow task scheduling algorithm based on the resources0 fuzzy clustering in cloud computing environment[J]. Int J Commun Syst. 2015;28(6):1053‐1067. 14. Sharifi L, Rameshan N, Freitag F, Veiga L. Energy efficiency dilemma: P2P‐cloud vs. data center. 2014 IEEE 6th International Conference on Cloud Computing Technology and Science.
22. Wang D, Yang Y, Mi Z. A genetic‐based approach to web service composition in geo‐distributed cloud environment[J]. Comput Electr Eng. 2015;43:129‐141. 23. Deb K, Pratap A, Agarwal S, Meyarivan T. A fast and elitist multiobjective genetic algorithm: NSGA‐II[J], IEEE transactions on evolutionary computation, 2012;6(2):182‐197.
How to cite this article: Zhang N, Yang X, Zhang M, Sun Y, Long K. A genetic algorithm‐ based task scheduling for cloud resource crowd‐ funding model. Int J Commun Syst. 2017;e3394. https://doi.org/10.1002/dac.3394
