Author’s Accepted Manuscript

Load-balancing Algorithms in Cloud Computing: A

Survey

Einollah Jafarnejad Ghomi, Amir Masoud

Rahmani, Nooruldeen Nasih Qader

www.elsevier.com/locate/jnca

PII: S1084-8045(17)30148-0
DOI: http://dx.doi.org/10.1016/j.jnca.2017.04.007
Reference: YJNCA1904
To appear in: Journal of Network and Computer Applications
Received date: 31 December 2016
Revised date: 6 March 2017
Accepted date: 7 April 2017
Cite this article as: Einollah Jafarnejad Ghomi, Amir Masoud Rahmani and
Nooruldeen Nasih Qader, Load-balancing Algorithms in Cloud Computing: A
S u r v e y , Journal of Network and Computer Applications,
http://dx.doi.org/10.1016/j.jnca.2017.04.007
This is a PDF file of an unedited manuscript that has been accepted for
publication. As a service to our customers we are providing this early version of
the manuscript. The manuscript will undergo copyediting, typesetting, and
review of the resulting galley proof before it is published in its final citable form.
Please note that during the production process errors may be discovered which
could affect the content, and all legal disclaimers that apply to the journal pertain.
Load-balancing Algorithms in Cloud Computing: A Survey

Einollah Jafarnejad Ghomia, Amir Masoud Rahmania*, Nooruldeen Nasih Qaderb

Email: [email protected]

Email: [email protected]

Email: [email protected]
a
Science and Research Branch, Islamic Azad University, Tehran, Iran.

b
Computer Science, University of Human Development, Sulaimanyah, Iraq.

*
Corresponding Author.

Abstract

Cloud computing is a modern paradigm to provide services through the Internet. Load balancing is a key
aspect of cloud computing and avoids the situation in which some nodes become overloaded while the
others are idle or have little work to do. Load balancing can improve the Quality of Service (QoS)
metrics, including response time, cost, throughput, performance and resource utilization.
In this paper, we study the literature on the task scheduling and load-balancing algorithms and present a
new classification of such algorithms, for example, Hadoop MapReduce load balancing category, Natural
Phenomena-based load balancing category, Agent-based load balancing category, General load balancing
category, application-oriented category, network-aware category, and workflow specific category.
Furthermore, we provide a review in each of these seven categories. Also. We provide insights into the
identification of open issues and guidelines for future research.
Keywords:

Cloud Computing, Load Balancing, Task Scheduling, Hadoop MapReduce.

1. Introduction
Cloud computing is a modern technology in the computer field to provide services to clients at any time.
In a cloud computing system, resources are distributed all around the world for faster servicing to clients
(Dasgupta et al., 2013). The clients can easily access information via various devices such as laptops, cell
phones, PDAs, and tablets. Cloud computing has faced many challenges, including security, efficient load
balancing, resource scheduling, scaling, QoS management, data center energy consumption, data lock-in
and service availability, and performance monitoring (Kaur et al., 2014; Malladi et al., 2015). Load
balancing is one of the main challenges and concerns in cloud environments; it is the process of assigning
and reassigning the load among available resources in order to maximize throughput, while minimizing
the cost and response time, improving performance and resource utilization as well as energy saving
(Singh et al., 2016; Goyal et al., 2016). Service Level Agreement (SLA) and user satisfaction could be
provided by excellent load balancing techniques. Therefore, providing the efficient load-balancing
algorithms and mechanisms is a key to the success of cloud computing environments. Several researches
have been done in the field of load balancing and task scheduling in cloud environments. However, our
studies showed that despite the key role of load-balancing algorithms in cloud computing, especially in
the advent of big data, there are a few comprehensive reviews of these algorithms. First, we mention a
few recent papers that have reviewed the load-balancing algorithms and mechanisms in cloud
environments:

 Milani et al., (2016) have presented a systematic review of the existing load balancing techniques.
They classified the existing techniques based on different parameters. The authors compared some
popular load-balancing algorithms and presented their main properties, including their advantages and
disadvantages. They also addressed the challenges of these algorithms and mentioned the open issues.
However, their work lacks a discussion regarding the load balancing and task scheduling techniques
in Hadoop MapReduce that is an issue nowadays.

 Mesbahi et al., (2016) have studied state of the art load balancing techniques and the necessary
requirements and considerations for designing and implementing suitable load-balancing algorithms
for cloud environments. They presented a new classification of load balancing techniques, evaluated
them based on suitable metrics and discussed their pros and cons. They also found that the recent load
balancing techniques are focusing on energy saving. However, their work suffers from the lack of
 simulating the load balancing techniques by simulator tools; in addition, a discussion of open issues
and future topics that researchers should focus on is also missing.

 Kanakala et al., (2015) have analyzed the performance of load balancing techniques in cloud
computing environments. They studied several popular load-balancing algorithms and compared them
based on metrics such as throughput, speed, complexity, etc. They concluded that none of the
reviewed algorithms were able to perform well in all the required areas of load balancing. However,
they did not mention the current trend, future works, and open issues in the field of load balancing in
cloud environments.

 Ivanisenko et al., (2015) have studied major load-balancing algorithms in distributed systems. They
classified the most used load-balancing algorithms in distributed systems, including cloud technology,
cluster systems, and grid systems. They also presented a comparative analysis of different load-
balancing algorithms on various efficiency indicators such as throughput, migration time, response
time, etc. In their work, a description of the main features of load-balancing algorithms, analysis of
their advantages, and defaults of each type of algorithms is also presented. Nevertheless, a discussion
of challenges, open issues, and future trends is similarly missing.

 Farrag et al., (2015) have reviewed intelligent cloud algorithms for load balancing problems,
including Genetic Algorithms (GA), Ant Colony Optimization (ACO), Artificial Bee Colony (ABC)
and Particle Swarm Optimization (PSO). They also proposed an implementation of Ant Lion
Optimizer (ALO) based cloud computing environment as an efficient algorithm, which was expected
to supply the outcomes in load balancing. The authors found that these algorithms showed a better
performance than traditional ones in terms of QoS, response time, and makespan. However, they did
not evaluate their proposed algorithm in different scales of cloud systems by comparing its results.

To help the future researchers in the field of load balancing in designing novel algorithms and
mechanisms, we surveyed the literature and analyzed state of the art mechanisms. Therefore, the purpose
of this paper is to survey the existing techniques, describe their properties, and clarify their pros and cons.
The main goals of this paper are as follows:

 Studying the existing load balancing mechanisms

 Providing a new classification of load balancing mechanisms

 Clarifying the advantages and disadvantage of the load-balancing algorithms in each class

 Outlining the key areas where new researches could be done to improve the load-balancing algorithms

The rest of the paper is organized as follows. Section 2 provides a literature review for the model, metrics,
policies, and taxonomy of load-balancing algorithms. Challenges in cloud-based load-balancing
algorithms are explained in section 3. Section 4 provides a relatively comprehensive review of literature
on the existing load balancing techniques and presents a new classification. Section 5 provides a
discussion of the mentioned techniques and some useful statistics. Open issues are outlined in section 6.
Finally, in section 7, we conclude our survey and provide future topics.

2. The load balancing model, metrics, and policies in literature

The model of load balancing is shown in Figure 1 (Gupta et al., 2014), where we can see the load
balancer receives users’ requests and runs load-balancing algorithms to distribute the requests among the
Virtual Machines (VMs). The load balancer decides which VM should be assigned to the next request.
The data center controller is in charge of task management. Tasks are submitted to the load balancer,
which performs load-balancing algorithm to assign tasks to a suitable VM. VM manager is in charge of
VMs. Virtualization is a dominant technology in cloud computing. The main objective of virtualization is
sharing expensive hardware among VMs. VM is a software implementation of a computer that operating
systems and applications can run on. VMs process the requests of the users. Users are located all around
the world and their requests are submitted randomly. Requests have to be assigned to VMs for processing.
Therefore, the task assignment is a significant issue in cloud computing. If some VMs are overloaded
while others are idle or have a little work to do, QoS will decrease. With the decreasing of QoS, users
become unsatisfied and may leave the system and never return. A hypervisor or Virtual Machine Monitor
(VMM) is used to create and manage the VMs. VMM provides four operations: multiplexing, suspension
(storage), provision (resume), and life migration (Hwang et al., 2012). These operations are necessary for
load balancing. In (Ivanisenko et al, 2015) it has been mentioned that load balancing has to consider two
tasks: resource allocation and task scheduling. The result of these two tasks is the high availability of
resources, energy saving, increasing the utilization of resources, reduction of cost of using resources,
preserving the elasticity of cloud computing, and reduction of carbon emission.
 Figure 1: The model of load balancing (Gupta et al., 2014).

2-1 Load balancing metrics

In this subsection, we review the metrics for load balancing in cloud computing. As mentioned before,
researchers have proposed several load-balancing algorithms. Literature in load balancing (e.g., Daraghmi
et al., 2015; Rastogi et al., 2015; Lua et al., 2011; Randles et al., 2010; Abdolhamid et al., 2014;
Abdullahi et al., 2015;, Kansal et al., 2012; and Milani, et al. 2016) proposed metrics for applying load-
balancing algorithms and we summarize them as follows:

 Throughput: This metric is used to calculate the number of processes completed per unit time.

 Response time: It measures the total time that the system takes to serve a submitted task.

 Makespan: This metric is used to calculate the maximum completion time or the time when the
resources are allocated to a user.

 Scalability: It is the ability of an algorithm to perform uniform load balancing in the system
according to the requirements upon increasing the number of nodes. The preferred algorithm is
highly scalable.

 Fault tolerance: It determines the capability of the algorithm to perform load balancing in the event
of some failures in some nodes or links.

 Migration time: The amount of time required to transfer a task from an overloaded node to an
under-loaded one.

 Degree of imbalance: This metric measures the imbalance among VMs.

  Performance: It measures the system efficiency after performing a load-balancing algorithm.

 Energy consumption: It calculates the amount of energy consumed by all nodes. Load balancing
helps to avoid overheating and therefore reducing energy usage by balancing the load across all the
nodes.

 Carbon emission: It calculates the amount of carbon produced by all resources. Load balancing has
a key role in minimizing this metric by moving loads from underloaded nodes and shutting them
down.

2-2 Taxonomy of load-balancing algorithms

In this subsection, we present the existing classification of load-balancing algorithms. In some studies
(Rastogi 2015; Mishra et al., 2015; Bhatia et al, 2012) load-balancing algorithms were classified based
on two factors: the state of the system and person who initiated the process. Algorithms based on the
state of the system are classified as static and dynamic. Some static algorithms are Round Robin, Min-
Min and Max-Min Algorithms, and Opportunistic Load Balancing (OLB) (Aditya et al., 2015). Some of
the dynamic algorithms include examples such as Ant Colony Optimization (ACO) (Nishant et al., 2012),
Honey Bee Foraging (Babu et al., 2013), and Throttled (Bhatia et al, 2012). Nearly all dynamic algorithms
follow four steps (Neeraj et al., 2014; Rathore et al., 2013; and Rathore et al., 2013):

 Load monitoring: In this step, the load and the state of the resources are monitored

 Synchronization: In this step, the load and state information is exchanged.

 Rebalancing Criteria: It is necessary to calculate a new work distribution and then make load-
balancing decisions based on this new calculation.

 Task Migration: In this step, the actual movement of the data occurs. When system decides to
transfer a task or process, this step will run.

The characteristics of static algorithms are:

1. They decide based on a fixed rule, for example, input load

2. They are not flexible
3. They need prior knowledge about the system.

The characteristics of dynamic algorithms are:

1. They decide based on the current state of the system

2. They are flexible

3. They improve the performance of the system

Dynamic algorithms are divided into two classes: distributed and non-distributed. In the distributed
approach, all nodes execute the dynamic load-balancing algorithm in the system and the task of load
balancing is shared among them (Rastogi et al., 2015). The interactions of the system nodes take two
forms: cooperative and non-cooperative. In the cooperative form, the nodes work together to achieve a
common objective, for example, to decrease the response time of all tasks. In the non-cooperative form,
each node works independently to achieve a local goal, for example, to decrease the response time of a
local task. Non-distributed algorithms are divided into two classes: centralized and semi-
distributed. In the centralized form, a single node called the central node executes the load-balancing
algorithms and it is completely responsible for load balancing. The other nodes interact with the
central node. In the semi-distributed approach, nodes in the system are divided into clusters and each
cluster is of centralized form. The central nodes of the clusters achieve load balancing of the system.
Static algorithms are divided into two categories: optimal, and sub-optimal (Neeraj et al., 2014). In
optimal algorithms, the data center controller determines information about the tasks and resources and
the load balancer can make an optimal allocation in a reasonable time. If the load balancer could not
calculate an optimal decision for any reason, a sub-optimal allocation is calculated. In an approximate
mechanism, the load-balancing algorithm terminates after finding a good solution, namely, it does not
search the whole solution space. After that, the solution is evaluated by an objective function. In a
heuristic manner, load-balancing algorithms make reasonable assumptions about tasks and resources. In
this way, these algorithms make more adaptive decisions that are not limited by the assumptions.
Algorithms in a sender-initiated strategy make decisions on arrival or creation of tasks, while algorithms
in a receiver-initiated strategy make load-balancing decisions on the departure of finished tasks. In a
symmetric strategy, either sender or receiver makes load-balancing decisions (Daraghmi et al., 2015;
Alakeel et al., 2010). A state of the art classification schema is shown in Figure 2.
 Figure 2: State of the art classification of load balancing strategies.

2-3 Policies in dynamic load-balancing algorithms

As mentioned before, dynamic load-balancing algorithms use the current state of the system. For this
purpose, they apply some policies (Daraghmi et al., 2015; Kanakala et al., 2014; Alakeel et al., 2010;
Yahaya et al., 2011; Mukhopadhyay et al., 2010; Babu et al., 2013; and Kumar et al., 2015]. These
policies are:

Transfer Policy: This policy determines the conditions under which a task should be transferred from one
node to another. Incoming tasks enter the transfer policy, which based on a rule determines the transfer of
the task or processes it locally. This rule relies on the workload of each of the nodes. This policy includes
task re-scheduling and task migration.

Selection policy: This policy determines which task should be transferred. It considers some factors for
task selection, including the amount of overhead required for migration, the number of non-local system
calls, and the execution time of the task.

Location Policy: This policy determines which nodes are under-loaded, and transfers tasks to them. It
checks the availability of necessary services for task migration or task rescheduling in the targeted node.

Information Policy: This policy collects all information regarding the nodes in the system and the other
policies use it for making their decision. It also determines the time when the information should be
gathered. The relationships among different policies are as follows. Incoming tasks are intercepted by the
transfer policy, which decides if they should be transferred to a remote node for the purpose of load
balancing. If the task is not eligible for transferring, it will be processed locally. If the transfer policy
decides that a task should be transferred, the location policy is triggered in order to find a remote node for
processing the task. If a remote partner is not found, the task will be processed locally, otherwise, the task
will be transferred to the remote node. Information policy provides the necessary information for both
transfer and location policies to assist them in making their decisions. These descriptions are summarized
in Table 1.

Table 1: Summary of load balancing policies

Policy Transfer policy Selection policy Location Information

policy policy

Descriptio Includes: Factors for Find suitable Determine the

n selection a task partner for time when the
task re-scheduling
to transfer: transfer task. information
task migration about nodes
Overhead of Checks the
has to gather.
Based on migration. availability of
thresholds in the services There of three
A number of the
terms of load necessary for types of
remote-system
units. migration information
calls.
within the policy:
The execution Partner.
Demand-driven
time of the task.
policy.

Periodic
policies.

State-change
driven policy.

3. Challenges in cloud-based load balancing

Review of the literature shows that load balancing in cloud computing has faced some challenges.
Although the topic of load balancing has been broadly studied, based on the load balancing metrics, the
current situation is far from an ideal one. In this section, we review the challenges in load balancing with
the aim of designing typical load balancing strategies in the future. Some studies have mentioned
challenges for the cloud-based load balancing (Palta et al., 2014; Nuaimi et al., 2012; Kanakala et al.,
2015; Khiyaita et al., 2012; Ray et al., 2012; and Sidhu et al., 2013], including:

A. Virtual machine migration (time and security)

The service-on-demand nature of cloud computing implies that when there is a service request, the
resources should be provided. Sometimes resources (often VMs) should be migrated from one
physical server to another, possibly on a far location. Designers of load-balancing algorithms have to
consider two issues in such cases: Time of migration that affects the performance and the probability
of attacks (security issue).

B. Spatially distributed nodes in a cloud

Nodes in cloud computing are distributed geographically. The challenge in this case is that the load
balancing algorithms should be designed so that they consider parameters such as the network
bandwidth, communication speeds, the distances among nodes, and the distance between the client
and resources.

C. Single point of failure

As mentioned in Section 2, some of the load-balancing algorithms are centralized. In such cases, if
the node executing the algorithm (controller) fails, the whole system will crash because of that single
point of failure. The challenge here is to design distributed or decentralized algorithms.

D. Algorithm complexity
The load-balancing algorithms should be simple in terms of implementation and operation. Complex
algorithms have negative effects on the whole performance.
E. Emergence of small data centers in cloud computing

Small data centers are cheaper and consume less energy with respect to large data centers.
Therefore, computing resources are distributed all around the world. The challenge here is to design
load-balancing algorithms for an adequate response time.

F. Energy management
 Load-balancing algorithms should be designed to minimize the amount of energy consumption.
Therefore, they should follow the energy-aware task scheduling methodology (Vasic et al., 2009).
Nowadays, the electricity used by Information Technology (IT) equipment is a great concern. In
2005, the total energy consumed by IT equipment was 1% of total power usage in the world
(Koomey et al, 2008). Google data centers have consumed 260 million Watts of energy that is equal
to 0.01% of the world’s energy [37]. Research has shown that on an average, 30% of cloud servers
exploit 10-15% of the resource capacity. Limited resource utilization increases the cost of cloud
center operations and power usage (Vasic et al., 2009; Koomey et al, 2008). Due to the tendency of
organizations and users to use cloud services, in the future, the installations of cloud providers will
expand and thus the energy usage in this industry will increase rapidly. This increase in energy usage
not only increases the cost of energy but also increases carbon-emission. If the number of servers in
data centers reaches a threshold, their power usage can be as much as that of a city. High energy
consumption has become a major concern for industry and society (Kansal et al., 2012).

What is the role of load balancing mechanisms in energy efficiency? In this section, we answer this
question. Our survey of the literature [Ahmad et al., 2015; Vasic et al., 2009; and Koomey et al, 2008)
clarified that developing energy-saving approaches in load balancing is on the way. Load-balancing
algorithms can be designed in ways that maximize the utilization of a physical server. For this purpose,
they monitor the permanent workload of servers and migrate VMs from under-loaded physical servers to
other servers and force some of the servers to enter a sleep state (shrinking the set of active machines). In
(Vasic et al., 2009) it has been shown that energy efficiency reaches a peak in full utilization of a
machine. Energy efficient load balancing mechanisms have to make a certain contribution to power
management too. In this way, load-balancing mechanisms are necessary for achieving green computing
in a cloud. In green computing, two factors are important: Energy usage reduction and carbon emission
reduction.

4. Survey on existing load balancing mechanisms

In this section, we survey the literature on the existing mechanisms for load balancing in cloud
environments. For this purpose, we studied a number of journals and conference proceedings to present a
new classification of them. We have classified the existing mechanisms into seven categories:
  Hadoop MapReduce load balancing category (HMR-category in this paper)

 Natural Phenomena-based load balancing category (NPH-based in this paper)

 Agent-based load balancing category (Agent-based in this paper)

 General load balancing category (GLB-category in this paper)

 Application oriented load balancing (AOLB-category in the paper)

 Network-aware task scheduling and load balancing (NATSLB-category in the paper)

 Workflow specific scheduling algorithms (WFSA-category in the paper)

In the next subsections, we will address each category.

4-1 An Introduction to Hadoop MapReduce

A large volume of data is produced daily, for example from, Facebook, Twitter, Telegram, and WEB.
These data sources together form big data. Hadoop is an open source framework for the storage and
processing of big data on clusters of commodity machines (Hefny et al., 2014; Chethana et al., 2016; and
Dsouza et al., 2015). We have summarized the architecture of Hadoop in Figure 3. Hadoop consists of
two core components, namely Hadoop Distributed File System (HDFS) for data storage and MapReduce
for data processing. HDFS and MapReduce follow master/slave architecture. A master node in HDFS is
called NameNode and slaves or workers are called DataNodes. For storing a file, HDFS splits it into
fixed-size blocks (i.e., 64MB per block) and sends them to DataNodes. NameNode does mapping of
blocks to workers. In MapReduce, the master node is called a JobTracker and slaves are called
TaskTrakers. User’s jobs are delivered to the JobTracker that is responsible for managing the jobs over a
cluster and assigning tasks to TaskTrackers. MapReduce provides two interfaces called Map and Reduce
for parallel processing. In general, the Map and Reduce functions divide the data that they operate on for
load balancing purposes (Sui et al., 2011). TaskTracker executes each map and reduce task in a
corresponding slot. Nodes in Hadoop spread over racks contained in one or several servers.
 Figure 3: The architecture of Hadoop.

4-1-1 Load Balancing Schedulers in Hadoop

Hadoop simplifies cluster programming as it takes care of load balancing, parallelization, task
scheduling, and fault tolerance automatically (Chethana et al., 2016; Vaidya et al., 2012, and Rao et al.,
2011). In other words, MapReduce, as the Google privacy strategy, hides the details of parallelization and
distribution. Scheduling in Hadoop MapReduce is achieved at two levels: job level and task level [Dsouza
et al., 2015 42]. In job level scheduling, jobs are selected from a job queue (based on a scheduling
strategy); in task-level scheduling, tasks of the job are scheduled. Scheduling strategies decide when and
which machine a task is to be transferred for processing (load balancing). Hadoop uses First-In-First-Out
(FIFO) strategy as its default scheduling, but it is pluggable for new scheduling algorithms. The scheduler
is a pluggable module in Hadoop, and users can design their own dispatchers according to their actual
application requirements (Khalil et al., 2013). Researchers have developed several scheduling algorithms
for the MapReduce environment that contribute to the load balancing (Manjaly et al., 2013; Patel et al.,
2015; Dagli et al., 2014; and Selv et al., 2016). In addition, several load-balancing algorithms are
developed as a plugin to standard MapReduce component of Hadoop. As mentioned before, any strategy
used for an even load distribution among processing nodes is called load balancing. The main purpose of
load balancing is to keep all processing nodes in use as much as possible, and not to leave any resources
in an idle state while some other resources are being overloaded. Conceptually, a load-balancing
algorithm implements a mapping function between the tasks and processing nodes (Destanoğlu et al.,
2008). According to this definition of load balancing, scheduling algorithms do the task of load balancing.
For this reason, we first surveyed and analyzed the load balancing schedulers in Hadoop.
A. FIFO Scheduling

FIFO is the default scheduler in Hadoop that operates on a queue of jobs. In this scheduler, each job is
divided into individual tasks that are assigned to a free slot for processing (Shaikh et al., 2017; Li et al.,
2015). A job dominates the whole cluster and only after finishing a job, the next job can be processed.
Therefore, in this scheduler job wait time, especially for short jobs, increases and no jobs could be
preempted. The default FIFO job scheduler in Hadoop assumes that the submitted jobs are executed
sequentially under a homogeneous cluster. However, it is very common that MapReduce is being
deployed in a heterogeneous environment; the computing and data resources are shared for multiple users
and applications.
B. Fair Scheduler
Facebook developed the fair scheduler (Zaharia et al., 2009). In this algorithm, jobs are entered into
pools (multiple queues) and in the case of multiple users; one pool is assigned to each user. Fair
scheduler distributes the available resources among the pools and tries to give each user a fair share of
the cluster over time, with each pool allocated a minimum number of Map and Reduce slots. If there are
free slots in an idle pool, they may be allocated to other pools, while extra capacity in a pool is shared
among the jobs. In contrast to FIFO, the fair scheduler supports preemption, therefore if a pool has not
received its fair share for a long time, then the scheduler will preempt tasks in pools running over
capacity in order to give the slots to the pool running under capacity. In this way, a long batch job cannot
block short jobs for a long time (Polato et al., 2014; Xia et al., 2011; and Zaharia et al., 2008).

C. Capacity Scheduler

Yahoo! developed the Capacity scheduler to guarantee a fair allocation of resources among a large
number of cluster users (Zaharia et al., 2009). For this purpose, it uses queues with a configurable
number of task slots (Map or Reduce). Available resources are assigned to queues according to the
priorities. If there are free resources in some queues, they are allocated to other queues (Hefny et al.,
2014; Chethana et al., 2016; and Polato et al., 2014). Within a queue, the priority of jobs is determined
based on the job arrival time, class of the job, and priority settings for users according to the Service
Level Agreement (SLA). When a slot in a TaskTracker becomes free, the scheduler chooses a job with
the longest waiting time from a queue with the lowest load. Therefore, the capacity scheduler enforces
cluster sharing among users, rather than among jobs, as is the case in the fair scheduler (Dsouza et al.,
2015; and Gautam et al., 2015).

D. Delay Scheduler

The delay scheduler is an optimization of the fair scheduler, which eliminates the locality issues of the
latter (Zaharia et al., 2010). We consider a scenario in which a slot becomes free and we have to select a
task of the job in front of a queue to process. It is possible that the data needed by this task does not exist
on the node with a free slot. This is a locality problem. In the delay scheduler, this task is temporarily
delayed until a slot in a node with the needed data becomes free. If the delayed time becomes long
enough, to avoid starvation, the non-local task is allowed to schedule (Manjaly et al., 2013).

E. Longest Approximate Time to End (LATE)

The LATE scheduler was developed to improve the job response time on Hadoop in heterogeneous
environments (Lee et al., 2011). Some tasks may progress slowly due to CPU high load, race condition,
temporary slowdown due to background processes, or slow background processes. These tasks are called

speculative tasks. The LATE scheduler tries to find a slow task and execute an equivalent backup task on
another node. This execution is called speculative execution. If the new copy of the task executes faster,
the whole job performance will improve. The LATE Scheduler assigns priorities to slow or failed tasks
for speculative execution and then selects the fastest nodes for that speculative execution. LATE
scheduling improves the response time of Hadoop in heterogeneous environments.

F. Deadline Constraint Scheduler

The deadline constraint scheduler was designed to satisfy the user constraints (Kc et al., 2010). The goals
of this scheduler are: (1) to be able to give users immediate feedback on whether the job can be completed
within the given deadline or not and proceed with the execution if the deadline can be met. Otherwise,
users have the option to resubmit with modified deadline requirements, (2) to maximize the number of
jobs that can be run in a cluster while satisfying the time requirements of all jobs [Dsouza et al., 2015;
Dsouza et al., 2015). Experiment results showed that when deadlines for the job is different, then the
scheduler assigns a different number of tasks to Tasktracker and makes sure that the specified deadline is
met.

We have thoroughly investigated and analyzed the scheduling algorithms in Hadoop. Our observations
are summarized in Table 2. The analysis table contains the names of the algorithms proposed by
researchers, parameters that they have tried to improve, advantages and disadvantages, and the tools
through which they have simulated their experiments.
Table 2: An overview of the current load balancing scheduler in Hadoop MapReduce

Algori Load Utiliza Starva Adap Job Throug Preem Advantages Disadvantages
thm balan tion tion tive alloca hput ptive
cing tion

FIFO No Low Yes No Static Low No Simple Only one job

implementa at a time uses
tion cluster
resources
Efficient
Low data
locality when
running a small
job on cluster

No considering
priority or job
size

No-support
multiuser
execution

Fair Relati High No Yes Static High Yes Distributes Does not
vely resources consider the
among jobs actual
fairly workload of
nodes for task
Fast
scheduling
response
which may
time for
result
both short
imbalance
and long
jobs

Improves
the QoS
through job
classificatio
n

LATE Yes High No Yes Static High Yes Suitable for It use the past
heterogeneo information
us
Is not suitable
environmen
for environment
t
with dynamic
 Improves the loading
performance
It does not
by reducing
ensure
response
reliability
time

Capaci Yes High No Yes Static High No Improves Users should

ty when resources acquire large
utilization amount of
job
information
fails It is flexible
about system
and efficient
to set a queue
It can be
used in
large
clusters

Delay Yes High May Yes Static High Yes Job Killing
response speculative
time may tasks is
decrease instantaneous

Killing
speculative
tasks wastes
the work
performed by
them

Does not
ensure
reliability

Deadli Yes High No Yes Dyna High Yes Focus on Homogeneous

ne mic increasing nodes are
system assumed

Works Dynamic job

better for deadline can
large affect the
clusters response time
utilization
the job may
not execute in
the system
due to its
deadline
 constraints

4-1-2 MapReduce optimization for load balancing

In this subsection, we review some of the algorithms proposed for MapReduce load balancing. In the
standard Hadoop MapReduce, each data file is divided into fixed-sized blocks and each block has
three replicas on three different DataNodes with two rules: (1) no two copies are on the same
DataNode, (2) no two copies are on the same rack, provided that there are enough racks. However, in
replica placement, the current load of DataNodes is irrelevant. A built-in tool called the balancer
executes repeatedly, the balancer moving data blocks from the overloaded DataNodes to under-
loaded ones (Lin et al., 2015). The balancer tool is used to balance an imbalanced cluster, but it would
be better if we could keep the cluster as balanced as possible from scratch. Furthermore, using the
balancer tool to load migration consumes a lot of system resources. Therefore, several researches
have tried to provide load-balancing techniques in the Hadoop environment; we have reviewed some
of them here.
 Valvåg et al. (Valvåg et al., 2011; Valvåg et al., 2009) proposed Cogset, a unified engine, for static
load balancing. The authors have found that the loose coupling between HDFS and MapReduce
engine is the cause of poor data locality for many applications. Rather than viewing the file system
and execution engine as separate and loosely coupled components, Cogset combines them closely
into a distributed storage system that supports parallel processing of data at the actual storage nodes.
Cogset consists of two stages: (1) data storage is distributed over the cluster through partitioning and
replications stage, (2) data access is achieved through a traversal stage. Due to the importance of load
balancing and fault tolerance, the replication mechanism is an integral part of Cogset. The work
provided a system with significantly better performance than Hadoop, in particular for small and
moderate data volumes; it is not fully scalable.
 Ahmad et al. (2012) proposed Tarazu, a suite of optimizations of MapReduce, to address the problem
of poor performance of MapReduce in heterogeneous clusters. The authors believe that the poor
performance of MapReduce is due to two factors: (1) MapReduce causes excessive and burst network
communication, (2) heterogeneity amplifies the Reduce load imbalance (Fadika et al., 2011). Tarazu
 consists of (1) Communication-Aware Load Balancing of Map computation (CALB) across the nodes,
(2) Communication-Aware Scheduling of Map computation (CAS) to avoid burst network traffic, and
(3) Predictive Load Balancing of Reduce computation (PLB) across the nodes. Authors showed by
simulation that using Tarazu significantly improves the performance over a traditional Hadoop
MapReduce in heterogeneous clusters.

 Kolb et al. (2011) proposed a block-based load-balancing algorithm, BlockSplit, to reduce search
space of Entity Resolution (ER). ER is the task of identifying entities referring to the same real-world
object. ER techniques usually compare pairs of entities by evaluating multiple similarity measures.
They utilize a blocking key based on the values of one or several entity attributes to divide the input
data into multiple partitions (blocks) and restrict the subsequent matching to entities of the same
block. For example, it is sufficient to compare entities of the same manufacturer when matching
product offers. The BlockSplit approach takes the size of the blocks into account and assigns entire
blocks to reduce tasks if this does not violate the load balancing constraints. Larger blocks are split
into smaller chunks based on the input partitions to enable their parallel matching within multiple
Reduce tasks (Kolb et al., 2012). The evaluation in a real cloud environment demonstrated that the
proposed algorithm was robust against data skew and scaled with the number of available nodes.

 Hsueh et al. (2014) proposed a block-based load-balancing algorithm for Entity Resolution with
multiple keys in MapReduce. Actually, the authors extended the BlockSplit algorithm presented in
(Kolb et al., 2011) by considering more than one blocking key. In their algorithm, the load
distribution in the Reduce phase is more precise because an entity pair may exist in a block only when
the number of common blocking keys between the pair exceeds a certain threshold (i.e., kc). Since an
entity may have more than one kc key, it needs to generate all the combinations of kc keys for
potential key comparisons. The proposed algorithm features in the combination-based blocking and
load-balanced matching. Experiments using the well-known CiteSeerX digital library showed that the
proposed algorithm was both scalable and efficient.

 Hou et al., (2014) proposed a dynamic load-balancing algorithm for Hadoop MapReduce. Their
algorithm balances the workload on a rack, while previous works tried to load balance between
individual DataNodes. In the standard MapReduce and its optimizations, there was no way for
Hadoop to guarantee that higher capability racks have more workload than lower capability racks. In
 other words, when assigning workload to DataNodes, the processing capacity was irrelevant. Their
work has two novelties: (1) They concentrate on load balancing between racks; (2) They use Software
Defined Network (SDN) to improve the data transfer. The results of simulation experiments showed
that by moving the tasks from the busiest rack to a less busy one, the finished time of these tasks
decreased substantially by adopting the algorithm.

 Vernica et al. (2012) proposed a suite of adaptive techniques to improve the MapReduce
performance. The authors have ignored the key assumption of MapReduce that mappers run in
isolation. They used an asynchronous channel called the Distributed Meta Data Store (DMDS) to
share the situation information between mappers. They used these mappers, called Situation-Aware-
Mappers (SAMs), to make traditional MapReduce more dynamic: (1) Adaptive Mappers, (2)
Adaptive Combiners, (3) Adaptive Sampling and Partitioning. Adaptive Mappers merge small
partitions into a virtual split thus making more splits that avoid frequent check pointing and load
imbalance (Doulkeridis et al., 2013). Adaptive Combiners perform a hash-based aggregation instead
of sort-based ones. In contrast to standard MapReduce, Adaptive Sampling creates local sampling
dynamically, aggregates them, and produces a histogram. Adaptive Partitioning can exploit the global
histogram to produce partitions of the same size for better load balancing. Although SAMs can solve
the data skew problem, they cannot solve the computational skew in reducers (Shadkam et al., 2014).
Experimental evaluation showed that the adaptive techniques dramatically improve the MapReduce
performance and especially performance stability.

 Yang et al., (2015) proposed an adaptive task allocation scheduler to improve MapReduce
performance in heterogeneous clouds. The paper makes improvements on the original speculative
execution method of Hadoop (called Hadoop Speculative) and LATE Scheduler by proposing a new
scheduling scheme known as Adaptive Task Allocation Scheduler (ATAS). The ATAS adopts more
accurate methods to determine the response time and backup tasks that affect the system, which is
expected to enhance the success ratio of backup tasks and thereby effectively increase the system’s

ability to respond. Simulation experiments showed that the proposed ATAS scheme could effectively

enhance the processing performance of MapReduce.

 Bok et al., (2016) proposed a scheduling scheme to minimize the deadline miss of jobs to which
deadlines are assigned when processing large multimedia data such as video and image in
MapReduce frameworks. The proposed scheme improves job task processing speed by utilizing a
 replica node of the same data required to process jobs if a node where I/O load is excessive is about to
process the jobs. A replica node refers to another node that has the data block required to process jobs
at available nodes. If available nodes are not found despite the expected job completion time
exceeding the deadline, the most non-urgent job is searched and the corresponding job task is
temporarily suspended to fasten the job completion time. The performance evaluation result showed
that the proposed scheme reduced completion time and improved the deadline success ratio.

 Ghoneem et al. (2016) introduced an adaptive scheduling technique for MapReduce scheduler to
increase efficiency and performance when it is used in the heterogeneous environment. In this model,
we make the scheduler aware of cluster resources and job requirement by providing the scheduler
with a classification algorithm. This algorithm classifies jobs into two categories executable and non-
executable. Then the executable jobs are assigned to the proper nodes to be executed successfully
without failures, which increase the execution time of the job. This scheduler overcomes the problems
of previous schedulers such as small job starvation, a sticky node in fair scheduler, and the mismatch
between resource and job. The adaptive scheduler increase performance of MapReduce model in the
heterogeneous environment while minimizing master node overhead and network traffic.

 Benifa et al. (2017) proposed a scheduling strategy named efficient locality and replica-aware
scheduling (ELRAS) integrated with an autonomous replication scheme (ARS) to enhance the data
locality and performs consistently in the heterogeneous environment. ARS autonomously decides the
data object be replicated by considering its popularity and removes the replica as it is idle. The results
proved the efficiency of the algorithm for heterogeneous clusters and workloads.

Now that we have reviewed some approaches to load balancing in MapReduce, it is time to investigate
and analyze them. In Table 3, we have summarized our analysis. The analysis table contains article year,
authors, key ideas, main objectives, advantages and disadvantages, evaluation techniques, and the journal
or conference that the article presented. We also showed the name of the publisher.
Table 3: An overview of the current load balancing strategies for Hadoop MapReduce.

Ye Auth Stati Key Idea Main Advantages Disadvantag Evaluation Journal/

ar ors c/ Objective es techniques
Conferen
Dyna
ce
mic

20 Ghon Dyna Handling Increasing Considerin Finding Implementin Proceedi

17 eem mic heterogenei the g job content g the ngs of
et al. ty and performan requireme information scheduler on the
(2016 scalability of ce of nts and is a cluster Internati
) Hadoop MapReduc node computation consisted of onal
MapReduce e using an capabilities ally three nodes Conferen
efficient expensive ce on
Reducing
scheduling and time- Data
makespan
consuming Engineeri
No ng and
starvation Commun
ication
Scalable Technolo
gy
(Springer
)

20 Benfi Dyna Using data Improving Effective No A Wireless

17 a et mic locality in throughpu utilization considering heterogeneo personal
scheduler t and of auto-scaling us cluster communi
al.
reducing resources applications built in cation
(2017
cross-rack for Amazon EC2 (Springer
) Providing
communic commercial Environment )
nearly
ation cloud as a testbed
optimal
environment
data
locality

Reducing
execution
time

Adaptable
for a wide
range of
application
s

20 Bok Dyna Employing Minimizing Reducing No Performance Multime

16 et al. mic speculative deadline completion implementat evaluation dia tools
(2016 tasks and miss of time ion in a real was and
) block jobs MapReduce conducted Applicati
Improving
replication environment with ons
Providing deadline
to avoid personal (Springer
MapReduc success
deadline computers )
e ratio
miss whose OS
scheduling
Considerin was
schema
g both I/O Windows 7
foe
loads in
multimedi
nodes and
a data
data
locality

20 Yang Dyna Improving Enhancing Increasing No, collect Installing Journal

15 et al. mic original MapReduc throughput data of run- heterogeneo of
(2015 LATE e model by time tasks us cloud Network
Reducing
) scheduler a task environment and
mean tasks
allocation by physical Compute
latency
scheduler and virtual r
Promote machines applicati
performanc ons
Using
e
VMWare for (Elsevier)
Considerin managing
g nodes
heterogene
ity

Data
locality, job
types, and
job
importance
are
considered

Backup
tasks
quickly

20 Hsue Dyna Solving the Load Using It may lead Experiments Twelfth
14 h et mic Entity balancing multiple to performed Australia
al.(20 Resolution among keys is duplicated in a 30- n
14)] problem for reducers used to comparisons nodes symposi
a huge sort the cluster um
Reducing
 collection of the entities, so which
entities with response the contains
multiple time of a matching three
blocking job step can be
types of
keys accelerated
nodes,
Efficiently
solves the
ER problem

20 Hou Dyna Balancing Decreasing Increasing Moving data Using IEEE,

14 et al. mic the the the entire between Mumak Fourth
(2014 workload completion performanc racks make which is Internati
) between time of job e of communicat Apache’s onal
different tasks. Hadoop ion Hadoop Conferen
racks on a overhead Map-Reduce ce on Big
Maintain Decreasing
Hadoop and simulator Data and
load task
cluster by consumes Cloud
balancing completion
considering network Computi
of clusters time
the bandwidth ng
capability of Increasing Do load
DataNodes the Map- balancing
Reduce between
performan racks
ce rather than
Data Nodes

20 Ahm Dyna Proposing a Eliminating Eliminate Tarazu Using a Proceedi

12 ad mic suite of the load the considers heterogeneo ngs of
optimization balancing bottleneck clusters with us cluster of the
et al.
for Map- problem of due to two classes 90 servers seventee
(2012
Reduce traditional shuffle or of hardware: comprising nth
)
Map- Map phase Atom, Xeon, 10 Xeon- internati
Reduce while based and onal
Load
literature 80 Atom- conferen
Eliminating balancing
showed that based server ce on
the in Map-
hardware in nodes Architect
communic Side
clusters has ural
ation
Load closely- Support
overhead
balancing related for
of
in Reduce- Program
traditional performance
Side ming
MapReduc
Languag
e in
es and
heterogam
Operatin
ous
 clusters g
Systems

(ACM)

20 Verni Dyna Breaking the Improving Adding Situation- Running ACM,

12 ca et mic key cluster new Aware experiments Internati
al. assumption performan runtime Mappers on a 42- onal
(2012 of isolation ce and options to continuously node IBM Conferen
) execution of simplify Hadoop monitor the system x ce on
Mappers in job tuning and made execution of iDataPlex Extendin
standard them mappers. dx340. Each g
Make
Map-Reduce Situation However, node had Database
Map-
Aware Situation- two quad- Technolo
Reduce
Aware core Intel gy
more Flexible
Mappers Xeon E5540
dynamics Map-
cannot 64 bit 2.83
Reduce
handle GHz
Tasks in computation processors,
Situation- al skew at 32 GB RAM,
Aware the and four
mappers reducers. SATA disks.
can alter The cluster
their consisted of
execution 336 cores
at runtime and 168
disks.

20 Kolb Dyna Even Increasing Handling Considering Running Proceedi

11 et al. mic redistributio the data skew one block experiments ngs of
n of data effectivene in Map- key for any with real- the 20th
(2011
between ss and Reduce entity world ACM
)
map and scalability datasets on internati
Suitable for It may lead
reduce tasks of Map- the Amazon onal
heterogene to imbalance
Reduce EC2 cloud conferen
ous cluster in reduce
computing ce on
Using phase due
Is used for using Informati
blocking- to using
all kind of Hadoop on and
techniques different-
paired-wise knowled
to facilitate sized sub-
similarity ge
entity block
computatio manage
resolution
n such as It consider ment
article multiple
comparison blocking key
as many
 individual
blocking key
that is time-
consuming

20 Valvå Stati Deterministi Increasing Ease of Reconfigurin Using a Sixth IFIP

09 g et c c split of the system implement g the cluster of 12 Internati
al. input efficiency ation placement Dell Power onal
dataset to of partitions Edge 1995 Conferen
(2009 Decreasing Supports
some in the machines ce on
) the appending
partitions presence of interconnect Network
request to,
failure, ed by an HP and
response readings
entail ProCurve Parallel
time and
copying a 4208VL with Computi
deleting
large a 24-port 1 ng
files in a
amount of Gbps
name (IEEE)
data switched
space
between Ethernet
Avoid nodes module
bottleneck
Does not
Reducing consider the
the heterogenei
layering ty
overhead
of software
running on
top of the
Map-
Reduce

4-2 Natural Phenomena-based load balancing category

In this section, we have surveyed several load balancing strategies that are inspired by natural phenomena
or biological behavior, for example, Ant-Colony, Honey-Bee, and Genetic algorithms.

 Yakhchi et al. (2015) proposed a load balancing method in cloud computing for energy saving by
simulating the life of a family of birds called cuckoos. They have used Cuckoo Optimization
Algorithm (COA). The cuckoos are species of birds that do not make nests for themselves. Cuckoos
lay eggs in the nests of other birds with similar eggs to raise their young. For this, cuckoos search for
the most suitable nests to lay eggs in order to maximize their eggs survival rate (Rajabioun et al.,
 2011). The load balancing method proposed in the paper consists of three different steps. In the first
step, the COA is applied to detect over-utilized hosts. In the second step, one or more VMs are
selected to migrate from the over-utilized host to other hosts. For this, they considered all the hosts
except the over-utilized ones as under-utilized hosts and attempted to migrate all their VMs to the
other host and switch them to sleep mode. It must be noted that if this process could not be
completed, the under-utilized host is kept active. Finally, Minimum Migration Time (MMT) policy is
used for selecting VMs from over-utilized and under-utilized hosts. The Simulation results
demonstrated that the proposed approach reduced energy consumption. However, the method may
cause SLA violation.

 Dasgupta et al., (2013) proposed a novel load-balancing strategy using a genetic algorithm (GA). The
algorithm tries to balance the load of the cloud infrastructure while trying to minimize the completion
time of a given task set. In the paper, a GA has been used as a soft computing approach, which uses
the mechanism of natural selection strategy. It is a stochastic searching algorithm based on the
mechanisms of natural selection and genetics. A simple GA is composed of three operations: (1)
selection, (2) genetic operation, and (3) replacement. The algorithm creates a “population” of possible
solutions to the problem and lets them “evolve” over multiple generations to find better and better
solutions. The authors have tried to eliminate the challenge of the inappropriate distribution of the
execution time, which is used to create the traffic on the server. Simulation results showed that the
proposed algorithm outperformed the existing approaches like First Come First Serve (FCFS).

 Nishant et al. (2012) proposed a load-balancing algorithm using the Ant Colony Optimization
(ACO). ACO is inspired from the ant colonies that work together in a foraging behavior. Inspired by
this behavior, authors of (Kabir et al., 2015) have used ACO for load balancing. In this algorithm,
there is a head node that is chosen in such a way that it has the highest number of neighbor nodes.
Ants move in two directions: (1) Forward movement; where ants move forward in a cloud to gather
information about the nodes’ loads, (2) Backward movement; if an ant finds an under-loaded node
(overloaded node) on its path, it goes backward and redistributes the load among the cloud nodes. The
main benefit of this approach lies in its detections of over-loaded and under-loaded nodes and thereby
performing operations based on the identified nodes.

 Babu et al., (2013) proposed a honeybee-based load balancing technique called HBB-LB that is
nature-inspired; it is inspired by the honeybee foraging behavior. This technique takes into account
 the priorities of tasks to minimize the waiting time of tasks in the queue. This algorithm has modeled
the behavior of honeybees in finding and reaping food. In cloud computing environments, whenever a
VM is overloaded with multiple tasks, these tasks have to be removed and submitted to the under-
loaded VMs of the same data center. Inspired by this natural phenomenon, the authors considered the
removal of tasks from overloaded nodes as the honeybees do. When a task is submitted to a VM, it
updates the number of priority tasks and the load of that VM and informs other tasks to help them in
choosing a VM. Actually, in this scenario, the tasks are the honeybees and the VMs are the food
sources. The experimental results showed that the algorithm improved the execution time and
reduced the waiting time of tasks on the queue.
We investigated and analyzed the NPH-based category of load-balancing algorithms. The results are
presented in Table 4. The analysis table contains article year, authors, key ideas, main objectives,
advantages and disadvantages, evaluation techniques, and the journal or conference that the article
presented. We also showed the name of the publisher.
4-3 Agent-based load balancing techniques
In this section, we have reviewed the literature that proposed agent-based techniques for load balancing in
cloud nodes. The dynamic nature of cloud computing is suitable for agent-based techniques. An agent is
a piece of software that functions automatically and continuously decides for itself and figures out what
needs to be done to satisfy its design objectives. A multi-agent system comprises a number of agents,
which interact with each other. To be successful, the agents have to able to cooperate, coordinate and
negotiate with each other. Cooperation is the process of working together, coordination is the process of
reaching a state in which their actions are well suited, and in negotiation process, they agree on some
parameters (Singha et al., 2015; Sim et al., 2011).

Table 4: An overview of the current NPH-based category load balancing techniques.

Ye Autho Key Idea Main Advantages Disadvantag Evaluation Publication/
ar rs objectives es techniques Presentation

20 Yakhc Using Reducing Simple policy Does not Simulation IEEE 6th
15 hi et Cuckoo energy for detecting provide any on CloudSim International
al. Optimizati consumption over-/ security toolkit Conference on
(2015 on under- policy for Modeling,
Maximizing
) Algorithm utilized hosts VM Simulation,
resource
for load and Applied
 balancing utilization Is suitable migration Optimization
in cloud for green
It does not
computing computing
clear
Using MMT live/dead
Minimum VM
Migration migration
Time for VM
VM
migration
migration
can increase
response
time

SLA
Avoidance

No guaranty
for QoS

20 Dasgu Using Load Improving Does not Simulation International

13 pta et Genetic balancing of system consider job on Conference on
al.(20 Algorithm cloud performance priorities CloudAnalys Intelligence:
13) (GA) for infrastructur t toolkit Modeling
Reducing job Low
load e Techniques
time span throughput
balancing and
Minimizing
in cloud Improve No power Applications(E
the
computing resource saving lsevier)
completion
utilization
time of a Lack of
given tasks scalability
set

20 Babu Inspiring Load Maximizing Starvation Simulation Applied Soft

13 et al. the balancing the for lower on CloudSim Computing
(2013 foraging VMS for throughput priority load toolkit
(Elsevier)
) behavior maximizing
Waiting time Lack of
of honey throughput
of tasks scalability
bee for
Minimizing become
load Single point
waiting time minimum
balancing of failure
of tasks in
VMS due to
queue
producing
bees from
single
source

20 Nisha Using Ant Load There is a Lack of No IEEE 14st

12 nt et Colony balancing of single result scalability simulation International
al. Optimizati nodes in set or Conference on
Lack of
(2012 on (ACO) cloud or grid implementa Modeling and
The task of throughput
) for load systems tion Simulation
each ant is
balancing Head node
Finding specialized
in cloud make a
optimal
computing To avoid bottleneck
resources to
overloads
process the Lake of a
due to ant
submitted mechanism
creation, it
jobs for head
uses a timer
node
to suicide.
selection
Detection of
It is not
over-/
clear the
under-
evaluation
loaded
method
nodes and
doing It might
operations cause data
accordingly transmissio
n break

 Singh et al., (2015) proposed a novel autonomous agent-based load-balancing algorithm called A2LB
for cloud environments. Their algorithm tries to balance the load among VMs through three agents:
load agent, channel agent, and migration agent. Load and channel agents are static agents whereas
migration agent is an ant, which is a special category of mobile agents. Load agent controls the
information policy and calculates a load of VMs after allocating a job. A VM Load Fitness table
supports the load agent. The fitness table maintains the list of all details of the VM properties in a
data center such as id, memory, a fitness value, and load status of all VMs. Channel agent controls the
transfer policy, selection policy, and location policy. Finally, the channel agent initiates the migration
agents. They move to other data centers and communicate with the load agent of that data center to
acquire the status of VMs present there, looking for the desired configuration. Result obtained
through implementation proved that this algorithm works satisfactorily.

 Gutierrez-Garcia et al., (2015) proposed an agent-based load balancing technique for cloud data
centers. The authors proposed a collaborative agent-based problem-solving technique capable of
 balancing workloads across commodity and heterogeneous servers by making use of VM live
migration. They proposed an agent-based load balancing architecture composed of VM agents, server
manager agents, and a front-end agent. They also proposed an agent-based load balancing mechanism
for cloud environments composed of (1) migration heuristics that determines which VM should be
migrated and its destination, (2) migration policies to select an AM for migration, (3) acceptance
policies which determine which VMs should be accepted, and (4) a set of load balancing heuristics of
the front-end to select the initial hosts of VMs. Simulation experiments showed that agents, through
autonomous and dynamic collaboration, could efficiently balance loads in a distributed manner
outperforming centralized approaches.

 Keshvadi et al., (2016) proposed a multi-agent load balancing system in an IaaS cloud environment.
Their mechanism performs both receiver-initiated and sender-initiated approach to balance the IaaS
load to minimize the waiting time of the tasks and guarantee the Service Level Agreement (SLA).
The mechanism presented in the paper comprises of three agents: (1) VMM Agent, (2) Datacenter
Monitor (DM), and (3) Negotiator Ant (NA). The VMM agent collects the CPU, memory and
bandwidth utilization of the individual VM hosted by different types of tasks to monitor the load. A
table for storing the state of the VMs supports this agent. The DM agent performs information policy
in a datacenter by monitoring the VMM’s information. This agent is supported by a table that
maintains all information about the status and characteristics of all VMs in a datacenter. It categorizes
the VMs based on their characteristics. DCM agents initiate NA agents. They move to other
datacenters and communicate with the DCM agent of those datacenters to acquire the status of VMs
there, searching for the desired configuration. Simulation results showed that the proposed algorithm
was more efficient and there was a good improvement in the load-balance, response time, and
makespan.

 Tasquier (2015) proposed an agent-based load balancer for multi-cloud environments. The author
proposed an application-aware, multi-cloud, and load-balancer based on a mobile agent paradigm. The
proposed architecture uses agents to monitor the status of the cloud infrastructure and detects the
overload and/or under-utilization conditions. The multi-agent framework provides provisioning
facilities to scale the application automatically to the under-loaded resources and/or to new resources
acquired from other cloud providers. Furthermore, the agents are able to deallocate unused resources,
thus leading to cost saving. The proposed architecture consists of three agents: (1) an executor agent,
 which represents the application running in multi-cloud environments, (2) a provisioner agent, which is
responsible for managing the cloud infrastructure through adding and removing resources, (3) a
monitor agent, which is responsible for monitoring the overload and/or under-utilization conditions.
Users can overview the current state of the cloud environment through an additional agent called
controllers. Moreover, each agent has mobility capabilities in order to migrate themselves
autonomously on the multi-cloud infrastructure. The proposed algorithm overcame the provider lock-
in challenge in the cloud and it was flexible to exploit the extreme elasticity.
We investigated and analyzed the agent-based load balancing techniques. The results are presented in
Table 5. The analysis table contains article year, authors, key ideas, main objectives, advantages and
disadvantages, evaluation techniques, and the journal or conference that the article presented. We also
showed the name of the publisher.

Table 5: An overview of agent-based load balancing techniques.

Ye Author Key Idea Main Advantages Disadvantag Evaluation Journal/
ar s objectives es techniques Confere
nce

20 Keshv Using Maximizing Increase the Datacenter Simulation using Internati

16 adi et Multiagen resource resource management CloudSim toolkit onal
al. t utilization utilization ants do not Robotics
Agents are
(2015) paradigm have a timer and
Load Avoid or programmed
for for self- Automat
balancing reduce using Java
dynamic destroying ion
across virtual dynamic language
load and wait for Journal
machines migration
balancing message
(MedCra
across Reducing the Reducing the from parent
ve)
virtual response migration
machines time cost
Using Guarantee Reducing the
both the SLA waiting time
senders- of tasks in
initiated queue
and
receiver-
initiated
approach
 es

20 Singh Using Load Improves Includes Implementation Internati

15 et al. software balancing resource heavy using Java onal
(2015) agents for VMs utilization computation technology Confere
load within a s nce on
Reducing
balancing datacenter Advance
service time Migration
in cloud and multiple d
agent does
computin datacenters Computi
search for
g ng
Reduces available
Technol
response VMs and is
ogies
time time-
and
consuming
Applicati
ons
(Elsevier
)

20 Gutier Using Efficient load Agents do does not Experiments Cluster

15 rez- agent- balancing in load estimate VM performed using Computi
Garcic based a distributed balancing migration agent-based ng
a et al. problem- manner using partial overhead test-bed such as (Springe
(2015) solving information MapLoad and r)
Provide no
technique about cloud Red Hat
usage
for load datacenters
prediction Test-bed was
balancing
Considering mechanism implemented in
in a
the Java and JADE
heterogen high
heterogeneit agent platform
eous migration
y of servers
environm overhead
and VMs
ent, live
VM It is a central
migration approach
and is not
fully scalable

20 Tasqui Using Multi-cloud Using multi- Not Does not COLUMB

15 er agent- load cloud implemente implemented or IA
([2015 based balancing resources for d or simulated Internati
) paradigm load simulated onal
Using full
for balancing Publishi
elasticity of Does not
developin ng
cloud Overcoming consider
g an Journal
environment the provider Quality of
applicatio of Cloud
s lock-in Service (QoS)
n aware computi
challenge in
multi- ng
 cloud load cloud Researc
balancer h
Is flexible to
exploit the
extreme
elasticity

4-4 General load balancing techniques

In this section, we have surveyed and overviewed the literature in the field of general load balancing
techniques. Although several algorithms are provided in this category, we have focused on new ones. For
example, techniques such as First-In-First-Out (FIFO), Min-Min, Max-Min, Throttled, and Equally
Spread Current Execution Load (ESCEL) are all belong to this category.

 Komarasamy et al., (2016) proposed a novel approach for dynamic load balancing in a cloud
environment. They called it dynamic load balancing with effective bin packing and VM
reconfiguration (DLBPR). DLBPR maps jobs into VMs based on the required processing speed of the
job. The main objectives of their work were process the jobs within their deadline and to balance the
load among the resources. In the proposed approach, the VMs are dynamically clustered as small,
medium and large according to process speed and the jobs are mapped into a suitable VM existing in
the cluster. The clusters are sometimes overloaded due to the arrival of a similar kind of job. In that
situation, the VMs may either split or integrate the VMs in the data center based on the request of the
job using a receiver-initiated approach. After reconfiguration, the VMs will dynamically regroup
based on the processing speed of the VMs. The proposed methodology is composed of three tiers: (1)
web tier, (2) schedule tier, (3) resource allocation tier. Users’ requests are submitted to the web tier at
any arbitrary time, which are forwarded to the scheduler tier. The deadline-based scheduler classifies
and prioritizes the incoming jobs. These jobs are processed efficiently by VMs in the resource
allocation tier. The proposed approach automatically improves the throughput and also increases the
utilization of the resources.
 Domanal et al., (2015) proposed a hybrid scheduling algorithm for load balancing in a distributed
environment by combining the methodology of Divide-and-Conquer and Throttled algorithms
referred to as DCBT. The authors defined two scenarios. In scenario 1, they deployed a distributed
environment that consists of a client, a load balancer and n nodes, which act as Request Handlers
(RH) or servers. The requests come from different clients and the load balancer assigns incoming
requests or tasks to the available RHs or servers. In scenario 2, the CloudSim simulator was used for
simulation which consisted of a data center, VMs, servers, and the load balancer. Here, the client’s
requests were coming from the Internet users. In both scenarios, the DCBT algorithm was used for
scheduling the incoming client's requests to the available RHs or VMs depending on a load of each
machine. The proposed DCBT utilizes the VMs more efficiently while reducing the execution time of
the tasks.

 Chien et al., (2016) proposed a novel load-balancing algorithm based on the method of estimating the
end of service time. In their algorithm, they considered the actual instant processing power of VM
and size of assigned jobs. They included two factors in the method of estimating the end-of-service
time in VMs: (1) the selected VM should be able to finish it as soon as possible, (2) on the next
allocation request, the load-balancing algorithm has to estimate the time that all queuing jobs and the
next incoming job are completely done in every VM. The VM that corresponds to the earliest will be
chosen to distribute the job. The simulation results showed that the proposed algorithm improves
response time and processing time.

 Kulkarni et al., (2015) proposed a novel VM load-balancing algorithm that ensures a uniform
assignment of requests to VMs even during peak hours (i.e., when the frequency of received requests
in the data center is very high) to ensure faster response times to users. They modified the active VM
algorithm implemented in the CloudAnalyst toolkit that has problems during the peak traffic
situation. For this purpose, in addition to an allocation table, they used a reservation table between the
phases of selection and allocation of VMs. The reservation table maintains the information of the VM
reservations suggested by the load balancer to data center controller, but they did not update the
allocation table until the notification arrives from allocation phase. The proposed load balancer takes
into account both reservation table entry and allocation statistics table entry for a particular VM id to
select a VM for the next request. The simulations results showed that the algorithm allocated requests
to VM uniformly even during peak traffic situations.
We have investigated and analyzed the general load balancing category; the results are presented in Table
6. The analysis table contains article year, authors, key ideas, main objectives, advantages and
disadvantages, evaluation techniques, and the journal or conference that the article presented. We also
showed the name of the publisher.

Table 6: An overview of current GLB-category load balancing techniques

Ye Authors Key Idea Main Advantages Disadvantag Evaluation Journal/Conf
ar objectives es techniques erence

20 Komara Using Bin Load Handles Using the Simulation Indian

16 samy et Packing balancing the user second table, in CloudSim journal of
al. algorithm virtual requests reservation toolkit Science and
(2016) and VM machines during peak table is space Technology
reconfigura situation consuming
Reducing job
tion for
waiting time Improves Does not
load
throughput consider
balancing in
energy
cloud Increases
saving
environmen resource
t utilization

Reduces
job waiting
time

20 Chien et Using the Reducing Considers Determining Simulation IEEE 18th

16 al. estimating the response the actual the actual using Internationa
(2016) method of time instant instant CloudSim l Conference
end of processing processing toolkit on Advance
Load
service time power of power is Communicat
balancing
to load VMs and complicated ion
VMs
balancing job size to Technology
Causes the
VMs Reducing assign jobs
problem of
the to VMs
energy
processing
Is more consumption
time
effective and carbon
 Improving emissions
response
time and
processing
time

20 Domana Combining Maximizing Maximize Did not Simulation IEEE

15 l et al. the Divide- resource resource simulate in in CloudSim Internationa
(2015) and- utilization utilization different toolkit l Conference
Conquer workload on cloud
Intelligently Reduces
methodolog situation computing
assign jobs total
y and in emerging
to VM for execution Does not
throttled markets
load time consider
algorithm
balancing considerabl deadline
to load
y constraints
balancing in Reducing
cloud the total
environmen execution
t time of tasks

20 Kulkarni Modifying Uniform Load Does not Simulation IEEE

15 et al. Active VM allocation of balancing allocate the using Internationa
(2015) Algorithm requests to VMs load CloudAnaly l Conference
implemente VMs even uniformly to st toolkit on Signal
It works
d in during peak VMs across Processing,
well during
CloudAnalys hours datacenters Informatics,
the peak
t to load deployed at Communicat
Reduce the hours
balancing different ion and
response
VMs Improve geographical Energy
time
the locations Systems
Using
elasticity
reservation
table
between
selection
and
allocation
phases

4-5. Application oriented load balancing techniques

In this section, we have surveyed and overviewed the literature in the field of application-oriented load
balancing techniques.
 Wei et al., (2015) proposed an efficient application scheduling in mobile cloud computing based on
MAX–MIN ant system. Firstly, the authors presented a local mobile cloud model with detail
application scheduling structure. Secondly, they presented a scheduling algorithm for the mobile
cloud model based on MAX–MIN Ant System (MMAS). Experiments results showed that the
algorithm could effectively promote the performance of the mobile cloud.
 Wei et al., (2013) defined the Hybrid Local Mobile Cloud Model (HLMCM) consisting of cloudlet
and mobile devices where cloudlet plays the role of a central broker while both neighboring mobile
devices and cloudlet play the role of service provider. The objective of application scheduling is to
maximize the profit as well as a lifetime of HLMCM while considering the capacity limitations of
service providers. They proposed the Hybrid Ant Colony-based Application Scheduling (HACAS)
algorithm to solve the scheduling problem. The algorithm only considers the available resources and
does not consider overhead when calculating the advantage ratio of mobile devices for joining the
cloudlet. Simulation results revealed that when the load of the system was heavy, HACAS algorithm
could select those applications with maximum profit and minimum energy consumption.
 Deye et al., (2013) proposed an approach to make load balancing more dynamic to better manage the
QoS of multi-instance applications in the cloud, the approach mainly limits the number of requests
through a load balancer equipped with a queue for incoming user requests at given time to send and
process the requests effectively. Simulation results showed that the approach improved the system
performance.
 Sarood et al., (2012) developed techniques that reduce the gap between application performance on
cloud and supercomputers. The scheme uses object migration to achieve load balance for tightly
coupled parallel applications executing in virtualized environments that suffer from interfering jobs.
While restoring load balance, it not only reduces the timing penalty caused by interfering jobs but
also reduces energy consumption significantly.

We have investigated and analyzed the application-oriented load balancing techniques; the results are
presented in Table 7. The analysis table contains article year, authors, key ideas, main objectives,
advantages and disadvantages, evaluation techniques, and the journal or conference that the article
presented. We also showed the name of the publisher.
Table 7: An overview of application-oriented load balancing techniques

Year Authors Key Ideas Main Advantages Disadvantages Evaluation Publication/

Objectives Techniques Presentation
2016 Wei et al.  Designing  Efficient  Improving  No considering CloudSim Soft computing
(2015) a mobile exploiting performanc dynamic (springer)
cloud of idle e resource
model computing,  Reducing requirement of
with storage energy applications
efficient and consumptio
applicatio sensing n
n capability  Improving
processin of mobile the profit of
g device scheduling
 Improving
QoS
2013 Deye et  Limiting  Making  More  No prediction CloudSim International
al. (2013) the load scalable the intensity of Conference on
number balancing  Reducing requests to Cloud Computing
of more the rate of obtain and Big Data
requests dynamic request appropriate (IEEE)
through  Mitigating rejection in number of
load the effects two cases: instances
balancer of with and
at a given interferenc without
time e of resource
sharing sharing
resources  Reducing
response
time
2013 Wei et all.  Verifying  Reducing  Decreasing  No adaptive CloudSim Journal of
(2013) the response response  No distributed Applied
definition latency time  Mobile device mathematics
s of  Maximizing  Decreasing can be (Hindawi)
mobile the profit energy overloaded
cloud  Improving consumptio  No considering
computin utilization n the completion
g  Integrated time of
 Providing cloudlet application in the
a Bio- with mobile scheduling
inspiring device algorithm
applicatio  In heavy
n load
schedulin situation
g selects an
algorithm application
with highs
profit and
min energy
consumptio
n
2012 Sarood et  Using a  Load  Reducing  No A testbed located 41st International
al. (2012) message balancing timing implementation at department of Conference on
driven for tightly penalty in a public cloud computer Parallel
adaptive coupled caused by  No decision science at the Processing
runtime parallel interfering making every university of Workshops(IEEE)
system application jobs time a load illinois Urbara
 Reducing balancer is Champaaign
energy invoked
consumptio
n
 Reducing
execution
time
4-6. Network-aware task scheduling and load balancing
In this section, we have surveyed and overviewed the literature in the field of network-aware task
scheduling and load balancing techniques.
 Shen et al., (2016) proposed a probabilistic network-aware task placement for MapReduce scheduling
to minimize overall data transmission cost and delays and hence to reduce job completion time while
balancing the transmission cost reduction and resource utilization. They found that a task is faced
with three challenges: (1) the available servers for running tasks dynamically change due to resource
allocation and release over time; (2) the data fetching time of reduce tasks depends on both the
placement of reduce tasks and the locations and sizes of the intermediate data produced by map tasks;
(3) the link load on the routing path also has a significant impact on the data access latency. In order
to reduce the latency, the link status of the network must be considered in the scheduling decision.
The experimental results showed that the scheduling algorithm improved the job completion time and
cluster resource utilization.
 Scharf et al., (2015) presented an extension of the OpenStack scheduler that enables a network-aware
placement of instances by taking into account bandwidth constraints to and from nodes. Their
solution follows the host-local network resource allocation, and it can be combined with bandwidth
enforcement mechanisms such as rate limiting. The author presented a prototype that requires only
very few changes in the OpenStack open source software. The authors showed that for heterogeneous
VMs, a network-aware placement could achieve a larger network throughput and a more predictable
performance, for example, by avoiding the congestion of network resources.
 Shen et al., (2016) proposed a new cloud job scheduler with elastic bandwidth reservation in clouds,
in which each tenant only needs to specify job deadline and each job’s reserved bandwidth is
elastically determined by leveraging the elastic feature to maximize the total job rewards, which
represent the worth of successful completion by deadlines. It also considers both the computational
capacity of VMs and reserved VM bandwidth in job scheduling. A simulation and real cluster
implementation results showed the efficiency and effectiveness of the algorithm in comparison with
other scheduling algorithms.
 Kliazovich et al., (2016) proposed a model, called CA-DAG, for cloud computing applications taking
into account a variety of communication resources of various types used in real systems. This
communication-aware model of cloud applications allows making separate resource allocation
decisions, assigning processors to handle computing jobs and network resources for information
transmissions, such as requests for application database. It is based on DAGs that in addition to
computing vertices include separate vertices to represent communications. The proposed
communication-aware model creates space for optimization of many existing solutions to resource
allocation and, together with performance and energy efficiency metrics of communication systems,
will become an essential tool in the design of completely new scheduling schemes of improved
efficiency.
We have investigated and analyzed the network-aware task scheduling and load balancing techniques; the
results are presented in Table 8. The analysis table contains article year, authors, key ideas, main
objectives, advantages and disadvantages, evaluation techniques, and the journal or conference that the
article presented. We also showed the name of the publisher.
Table 8: An overview of network-aware task scheduling and load balancing

Year Authors Key Ideas Main Advantages Disadvantages Evaluation Publication/

Objectives Techniques Presentation
2016 Shen et  Considering  Minimizing  Reducing  The optimality  Implementing IEEE
al. (2016) network data job of exponential the algorithm International
topology and transmissi Completion model is not on Apache Conference on
transmission on cost time known Hadoop cluster
cost in job  Balancing  Increasing  Performance  Conduct computing
scheduling transmissi cluster of the model experiments
on cost utilization did not on a high-
reduction  Minimizing evaluate under performance
and delay different computing
resource network platform
utilization conditions
2016 Shen et  Using elastic  Finding a  Minimizing  No automatic  Using IEEE
al. (2016) bandwidth job total job bandwidth Facebook International
reservation schedule rewards reservation synthesized Conference on
in clouds to satisfy  Reducing workload Cloud
the job  Simulated Computing
deadline execution datacenter Technology an
requireme time with a rack Science
nts  Efficiency consists of 40
and machines
effectivenes  Implementing
s the algorithm
 Real
implementati
on
2016 Kliazovich  Using a  Assigning  Considering  No practical  Using Winkler Journal of Grid
(2016) communicati processor the validation of graph Computing
on- aware s to dynamics of proposed generator to (Springer)
model in handle cloud solution produce
cloud computing environment  No considering workload
computing jobs  Using heterogeneity  Testbed
(CA-DAG)  Using context-data of cloud system
network including environment architecture
resources network composed of
for topology for a set of
informatio scheduling identical
n  optimizing servers
transmissi makespan
on
2015 Scharf et  Network  Extension  Increasing  Fixing time  A testbed IEEE 24th
al. (2015) aware- of throughput granularity of setup of International
placement of OpenStac  More control loop to OpenStack Conference on
instances by k predictable 10 sec. “Icehouse” Computer
taking into Scheduler performance  Relying on consisting of a Communication
account existing filters few servers and Network
bandwidth prevents the (ICCCN)
constraints use of
bandwidth as a
metric
 No considering
the actual
topology of
network
4-7 Workflow specific scheduling algorithms
In this section we have surveyed and overviewed the literature on workflow specific scheduling
algorithms; articles with regard to bag of tasks, dependent task, priority based task scheduling are
reviewed.

 Ghosh et al., (2016) proposed a new enhanced algorithm and implemented it in cloud computing
environment, which adds a new feature like priority basis service of each request. Determining the
priorities of a request, the request allocated to VMs. A Switching queue has proposed to hold the
requests, which have been removed temporarily from the VM due to the arrival of higher priority
request earlier. The authors analyzed the performance of their algorithm with respect to Throttled
Load Balancing algorithms and Round Robin.

 Jaikar et al., (2014) proposed system architecture and the VM allocation algorithm for the load
balancer in a scientific federated cloud. They tested the proposed approach in a scientific federated
cloud. Experimental results showed that the proposed algorithm not only increased the utilization of
resources but also reduced the energy consumption.

 Moschakis et al., (2015) developed the simulated annealing and thermodynamic simulated annealing
in the multi-criteria scheduling of a dynamic multi-cloud system with VMs of heterogeneous
performance serving Bag-of-Tasks (BoT) applications. The scheduling heuristics applied, consider
multiple criteria when scheduling said applications and try to optimize both for performance and cost.
Simulation results indicated that the use of these heuristics could have a significant impact on
performance while maintaining a good cost-performance trade-off.

 Cai et al., (2015) proposed A delay-based dynamic scheduling algorithm (DDS), DDS is a dynamic
cloud resource provisioning and scheduling algorithm to minimize the resource renting cost while
meeting workflow deadlines. New VMs are dynamically rented by the DDS according to the practical
execution state and the estimated task execution times to fulfill the workflow deadline. The bag-based
deadline division and bag-based delay scheduling strategies consider the bag structure to decrease the
total renting cost. The results showed that the algorithm decreased the resource renting cost while
guaranteeing the workflow deadline compared to the existing algorithms
 Cinque et al., (2016) proposed a Grid Architecture for scalable Monitoring and Enhanced dependable
job ScHeduling (GAMESH). GAMESH is a completely distributed and highly efficient management
infrastructure for the dissemination of monitoring data and troubleshooting of job execution failures
in large-scale and multi-domain Grid environments. The solutions improve job processing throughput
in both intra/inter-domain environments.

 Bellavista et al., (2016) proposed GAMESH, a Grid Architecture for scalable Monitoring and
Enhanced dependable job ScHeduling. The proposed solution is conceived as a completely distributed
and highly efficient management infrastructure. The paper relevantly extends the authors previous
work appeared in (Cinque et al., 2016). With respect to it, this extended version provides additional
details about the effective design and implementation of selected and primary GAMESH components.
In addition, it reports a novel and extensive measurements in both intra-domain and inter-domain
deployments. Moreover, it provides the detailed description of the original Stochastic Reward
Network models that have been produced to perform the simulation of the GAMESH failure-aware
scheduling solution. The proposed solution improves job processing throughput in both intra/inter-
domain environments.
 Kianpishe et al. (2016) investigated the problem of workflow scheduling regarding the user-defined
budget and deadline. The probability of violation of constraints (POV) has been used as robustness
criteria for a workflow schedule at run-time. By aggregating the execution time distributions of the
activities on the critical path the Probability Density Function (PDF) of makespan is computed. Ant
Colony System has been utilized to minimize an aggregation of violation function and POV.
 Zhang et al., (2015) proposed an Improved Adaptive heuristic algorithm (IAHA). At first, the IAHA
algorithm makes tasks prioritization in complex graph considering their impact on each other, based
on graph topology. Through this technique, the completion time of application can be efficiently
reduced. Then, it is based on adaptive crossover rate and mutation rate to cross and mutate to control
and lead the algorithm to an optimized solution. The experimental results showed that the proposed
method improved response time and makespan.
We have investigated and analyzed the network-aware task scheduling and load balancing techniques; the
results are presented in Table 9. The analysis table contains article year, authors, key ideas, main
objectives, advantages and disadvantages, evaluation techniques, and the journal or conference that the
article presented. We also showed the name of the publisher. We specified in column “Focus on”, which
subcategory the algorithm belongs to.
 Table 9: An overview of workflow specific scheduling algorithms

Year Authors Key Idea Main Advantages Disadvantages Evaluation Journal/Conference Focus on
Objectives techniques
2017 Cai et al.  Providing  Full fill the  Minimizing  Expectation  Using Journal of Future Bag of
(2015) dynamic workflow the cloud and variance ElasticSim Generation tasks
cloud deadline resource based task tool Computer Systems
resource renting cost execution (Elsevier)
scheduling  Fully use the time
algorithm for bag structure estimation
BoT  A single type method
workflow based greedy overestimate
method for the practical
each ready task
BoT execution
times to
some degree
2016 Ghosh et  Priority  Improving  Reducing  May cause CloudSim International Priority
a. (2016)] based average response starvation for simulation tool Conference on based
service execution time low priority Inventive
allocation of time  Reducing requests Computation
each user execution  Long Technology (IEEE)
request time response
 Improving time for low
service priority jobs
quality
2016 Cinque et  Providing  Improving  Scalable  No, consider  Implementing Proceedings of the Dependable
al. (2016) failure-aware the  Improving the situations on a real grid 31st Annual ACM scheduling
scheduling execution performance where Symposium on
approaches of heavy  Reducing multicast is Applied
and scalable job bandwidth not available Computing(ACM)
monitoring batches consumption
for grid  Improving
throughput
2016 Bellavista  Using the  Providing  Decentralized  Not fully  implemented Journal of Future Dependable
et al. publish/subscri scalable scheduler scalable and tested in Generation scheduling
(2016) be paradigm monitoring  A novel  No job a real Computer Systems
for intra- and troubleshooti completion deployment (Elsevier)
domain enhanced ng algorithm efficiency on distributed
scenarios dependabl  Use standard data centers
e job technology to across
schedulin avoid vendor Europe
g lock-in
 Providing
failure-aware
scheduling
2016 Kianpishe  Using ant  Minimizing  Reducing the  No avoid  Simulation Cluster Computing Workflow
et al. colony the probability of run-time on real world (Springer) Scheduling
(2016) system to violation violation of violations workflow
develop a of workflow  No track the
robust workflow constraints workflow at
workflow constraint  Reducing runtime
scheduler s expected
 Minimizing penalty at
probability run-time
of  Decreasing
violations makespan
and cost
 Considering
budget and
deadline of
workflows
2015 Moschakis  Scheduling  Optimizing  Reducing  The policy of  Proposed Journal of Systems Bag of
et al. of bag of interlinked Makespan spreading approach and Software tasks
(2015) tasks cloud  Maintaining a parallel tasks tested in a (Elsevier)
applications systems good cost- between the scientific
 Optimizing performance clouds is not federated
performan trade-off clear cloud
ce and  Increasing  No real
cost implementati
 utilization on in cloud
 Improving system
performance
2015 Zhang et  Using an  Proper  Reducing  Not fully  CloudSim Third International Workflow
al. (2015) adaptive mapping response adaptive simulation Conference on Scheduling
heuristic of tasks to time  Focus only tool Advanced Cloud
algorithm for resources  Optimizing on compute and Big Data(IEEE)
workflow makespan intensive
scheduling  Optimizing applications
load  No
balancing considering
 Optimizing communicati
failure rate of on-intensive
tasks
2014 Jaikar et  Presenting  Increasing  Considering  No providing Implementing IEEE 3rd Priority
al. (2014) priority- resource a scientific migration the algorithm in International based
based VM utilization federated policies OpenNebula Conference on
allocation  Reducing cloud  There is no Cloud Computing
algorithm energy  Reducing cost function (CloudNet)
consumpti total job for cross-
on execution cloud VM
time migration
 Improving
resource
utilization
 Increasing
system
performance
5. Discussion and statistics
In this section, we provide some statistics based on the studied articles. Figure 4 shows the distribution of
the reviewed articles by the year of publication from 2008 until February 2017. In the Figure we see the
number of articles in each year on the corresponding slice; for example, the number of studied articles in
2015 is 29 that is the highest. The percentage of studied articles in each year is shown in the Figure too.
Moreover, the number of articles in 2016 is noteworthy. Figure 4 shows that 3% of the articles were
published in 2017, 17% of them were published in 2016, 27% of them were published in 2015, 11% of
them published in 2014, and 9% of them published in 2013. It means that 72% of the studied articles have
been published in the last five years.
The distribution of the studied from different publishers is shown in Figure 5. In the Figure, the article
 Figure 4: The distribution of studied articles over time Figure 5: The distribution of studied articles
From 2008 until February 2017. based on different publishers.
frequency of each publisher is shown on the corresponding slice, where 29 out of 108 total articles of
journals belong to IEEE (27%). To further investigate the foundation journal of article, 12% of the
literature is related to Elsevier, 10% of the literature is related to Springer, 8% of the literature
belongs to ACM, 2% of the literature belongs to IJMECE, 2% of the literature is related to ACEEE,
42% of them published by others.
In Table 10 and Figure 6, we showed how the studied articles addressed the load balancing QoS
metrics. The information is extracted from Tables 3 to 9. By referring to Table 10, we can
differentiate the articles based on single objective and multi-objective load balancing techniques.
References (Hsueh et al., 2014), (Hou et al., 2014), (Babu et al., 2013), (Chien et al., 2016), (Scharf et
al., 2015), (Shen et al., 2016), (Bok et al. 2016), and (Kliazovich et al., 2016) in the Table are single
objective while the others are multi-objective. Figure 6 shows that 22% of the studied techniques
addressed the response time metric, 24% addressed the makespan, 19% addressed the resource
utilization metric, 9% addressed the throughput, %9 addressed the energy saving, 9% addressed the
scalability, 8% addressed the migration time metric. We see that the majority of techniques have
concentrated on the response time and makespan metrics.
Table 10: Load balancing QoS metrics in the reviewed techniques.
# Energ Migrati Resource
Respon Scalabili Through Makespa
References y on utilizatio
se time ty put n
saving time n

1 Scharf et al. (2015)

2 Shen et al. (2016)

3 Keliazovich (2016)

4 Hou et al. (2014)

5 Bok et al. (2016)

6 Hsueh et al. (2014)

7 Babu et al. (2013)

8 Chient et al. (2016)

9 Yakhchi et al. (2015)

10 Dasgupta et al. (2013)

11 Nishant et al. (2012)

12 Singh et al. (2015)

13 Gutierrez-Garcia et al.
(2015)

14 Keshvadi et al. (2015)

15 Tasquire (2015)

16 Kumarasamy et al.
(2015)

17 Domanal et al. (2015)

18 Kulkarni et al. (2015)

19 Ghoneem et al. (2016)

20 Benfia et al. (2017)

21 Yang et al. (2015)

22 Wei et al. (2015)

23 Deye et al. (2013)

24 Wei et al. (2013)

25 Sarood et al. (2012)

26 Shen et al. (2016)

27 Ghosh et al. (2016)

28 Cinque et al. (2016)

29 Kianpishe et al. (2016)

30 Maschakis et al. (2015)

31 Zhang et al. (2015)

32 Jaikar et al. (2014)

33 Total 7 6 17 7 14 7 18

Evaluation techniques used in the articles and the corresponding statistics are shown in Figure 7. We
divided evaluation techniques in five classes: Real Testbed, CloudSim, Witten Program,
CloudAnalyst and the others. Article frequencies in each class are shown on the corresponding slice;
19 articles used a real testbed for algorithm evaluation, eight articles used CloudSim, authors of three
articles wrote a program for algorithm evaluation, two articles used CloudSim, and seven articles
used other techniques. To further investigate the foundation evaluation techniques of the articles, 49%
of the literature used a real testbed that is the highest, and 20% of them used ClousSim, 3% of them
used an arbitrarily written program, 2% of them used CloudAnalyst, and 18% of them used other
tools.

Figure 6: An overview of load balancing metrics

Figure 7: Evaluation techniques used by articles
addressed by the reviewed techniques.
 The venue types of papers are shown in Figure 8. In the Figure, the absolute number of
papers in each venue and the percentage are shown. It is shown that 20 papers presented on
the conference, 16 papers published in journals, and two papers presented in a symposium.
To further investigate the paper, 53% of the literature presented on the conference, 42%
published in journals, and 5% presented in symposium.

Figure 8: Studies venue types.

6. Open Issues and Future Trends
In this section, we offer major load balancing techniques issues that have not been comprehensively and
completely addressed. In our literature review, we found that there is not a perfect technique for
improving the entire load balancing metrics. For example, some techniques considered response time,
resource utilization, and migration time, while the others ignored these metrics and considered other
metrics. However, it seems that some metrics are mutually exclusive. For example, relying on VM
migration for load balancing may cause an increase in the response time. Service cost is another metric,
which is not considered in the studied articles. Presenting a comprehensive technique to improve as many
metrics as possible is, therefore, very desirable.
Furthermore, our study showed that the energy consumption and carbon emission are two important
drawbacks due to the incremental growth of the number of datacenters. However, just a few articles
addressed these two drawbacks. Energy consumption is regarded as an economic efficiency factor while
carbon emission is regarded as a health-related, and/or an environmental factor. Each of these issues is
critically important. Therefore, providing load balancing mechanisms in a cloud environment while also
addressing these two problems is very desirable too.
Recently, a large volume of data is produced daily from social networks, medical records, e-commerce,
e-shopping, e-pay, banking records, etc. This huge volume of data makes big data, and therefore needs
near-perfect distribution for fast servicing. Our study showed that in recent years just a few articles
addressed this topic. Further optimization of Hadoop MapReduce for processing big data in the future
research, is quite promising.
Recently, in addition to the existing popular cloud providers such as Google, Microsoft, and Amazon,
other cloud providers are growing too. In some situations, it is necessary for a cloud provider to send
some workload to another cloud provider for processing for the purpose of load balancing. In other
words, using resources of more than one cloud provider is a critical requirement for load balancing in the
future. In this case, the cloud providers will face data lock-in problems. Our study shows that just a few
articles have paid attention to these topics. Therefore, another interesting line for future research can be
the investigation of data lock-in and cross-cloud servicing problems.

7. Conclusion and future works

Balancing of the workload among cloud nodes is one of the most important challenges that cloud
environments are facing today. In this paper, we surveyed research literature in the load balancing area,
which is the key aspect of cloud computing. We found in the literature, several metrics for load balancing
techniques that should be considered in future load balancing mechanisms. Based on our observations, we
have presented a new classification of load balancing techniques: (1) Hadoop MapReduce load balancing
category, (2) natural phenomenon-based load balancing category, (3) agent-based load balancing
category, and (4) general load balancing category. In each category, we studied some techniques and
analyzed them in terms of some metrics and summarized the results in tables. Key ideas, main objectives,
advantages, disadvantages, evaluation techniques, publication year were metrics that we considered for
load balancing techniques. Recently, load balancing techniques are focusing on two critical metrics, That
is, energy saving and reducing carbon dioxide emission. As future works, we suggest the followings: (1)
Study and analyze more recent techniques in each of our proposed categories, (2) Evaluate each technique
in a simulation toolkit and compare them based on new metrics.

References
[1] Shaikh, B. and Shinde, K., and Borde, S. (2017). Challenges of Big Data Processing and Scheduling
of Processes Using Various Hadoop Schedulers: A Survey. International Journal of Multifaceted and
Multilingual Studies. 3(12).
[2] Mesbahi, M. and Rahmani, AM. (2016). Load Balancing in Cloud Computing: A State of the Art
Survey”, International Journal of Modern Education and Computer Science. 8(3), 64.
[3] Daraghmi, EY. and Yuan, SM.(2015). A small world based overlay network for improving dynamic
load-balancing. Journal of Systems and Software. 107, 187-203.
[4] Rastogi, G. and Sushil, R. (2015). Analytical Literature Survey on Existing Load Balancing Schemes
in Cloud Computing. International Conference on Green Computing and Internet of Things (ICGCloT).
[5] Kanakala, VRT. and Reddy, VK. (2015). Performance Analysis of Load Balancing Techniques in
Cloud Computing Environment. TELKOMNIKA Indonesian Journal of Electrical Engineering, 13(3),
568-573.
[6] Palta, R. and Jeet, R., (2014). Load Balancing in the Cloud Computing Using Virtual Machine
Migration: A Review. International Journal of Application or Innovation in Engineering & Management
(IJAIEM), 3(5),437-441.
[7] Ivanisenko, IN. and Radivilova, TA. (2015). Survey of Major Load-balancing algorithms in
Distributed System. Information Technologies in Innovation Business Conference (ITIB).
[8] Dasgupta, K. and Mandalb, B., Duttac, P., Mondald, JK., and Dame, S. (2013). A Genetic Algorithm
(GA) based Load-balancing strategy for Cloud Computing”, International Conference on Computational
Intelligence: Modeling Techniques and Applications (CIMTA), 10, 340-347.
[9] Gupta, H. and Sahu, K. (2014). Honey Bee Behavior Based Load Balancing of Tasks in Cloud
Computing. International Journal of Science and Research (IJSR), 3(6).
[10] Lua, Y., Xie, Q., Klito, G., Geller, A., Larus, JR., and Greenberg, A. (2011). Join-Idle-Queue: A
novel load-balancing algorithm for dynamically scalable web services. International Journal on
Performance evaluation, 68, 1056-1071.
[11] Neeraj, R., and Chana, I., (2014). Load balancing and job migration techniques in grid: a survey of
recent trends. Wireless Personal Communications, 79(3), 2089-2125.
[12] Kaur, R. and Luthra, P.(2014). Load Balancing in Cloud Computing”, International Conference on
Recent Trends in Information. Telecommunication and Computing, ITC, pp. 1–8.
[13] Malladi, RR.(2015). An Approach to Load Balancing In Cloud Computing. International Journal of
Innovative Research in Science, Engineering and Technology, 4(5), 3769-3777.
[14] Jadeja, Y. and Modi, K. (2012). Cloud Computing - Concepts, Architecture and Challenges.
International Conference on Computing, Electronics and Electrical Technologies [ICCEET].
[15] Nuaimi, K. and Mohamed, N., Mariam Al-Nuaimi, M., and Al-Jaroodi, J. (2012). “A Survey of
Load Balancing in Cloud Computing: Challenges and Algorithms”, IEEE Second Symposium on
Network Cloud Computing and Applications.
[16] Kanakala, VRT. and Reddy, VK. (2015). Performance Analysis of Load Balancing Techniques in
Cloud Computing Environment., TELKOMNIKA Indonesian a Journal of Electrical Engineering, 13(3),
568-573
[17] Randles, M. and Lamb, D., and Tareb-Bendia, A. (2010). A Comparative Study into Distributed
Load-balancing algorithms for Cloud Computing”, IEEE 24th International Conference on Advanced
Information Networking and Applications Workshops, pp. 551–556.
[18] Singha, A. and Juneja, D., and Malhotra, M. (2015). Autonomous Agent Based Load-balancing
algorithm in Cloud Computing. International Conference on Advanced Computing Technologies and
Applications (ICACTA), 45, 832–841
[19] Abdolhamid, M. and Shafi’i, M., Bashir, MB. (2014). Scheduling Techniques in On-Demand grid as
a Service Cloud: A Review”, Journal of Theoretical and Applied Information Technology, 63(1), pp.10 -
19
[20] Abdullahi, M., Md Asri Ngadi, MdA., and Abdulhamid, SM.(2015). Symbiotic Organism Search
Optimization based Task Scheduling in Cloud Computing Environment. Future Generation Computer
Systems, 56, 640-650.
[21] Aditya, A. and Chatterjee, U., and Gobata, S. (2015). A Comparative Study of Different Static and
Dynamic Load-balancing algorithm in Cloud Computing with Special Emphasis on Time Factor.
International Journal of Current Engineering and Technology, 3(5).
[22] Khiyaita, A., Zbakh, M., Bakkali, HEI., and Kettani, DEI.(2012). Load balancing cloud computing:
state of art. Network security and systems (JNS2), 106–09

[23] Mishra, NK. and Misha, N. (2015). Load Balancing Techniques: Need, Objectives and Major
Challenges in Cloud Computing: A Systematic Review. International Journal of Computer, 131(18).
[24] Bhatia, J. and Patel, T., Trivedi, H., and Majmudar, V. (2012). HTV Dynamic Load-balancing
algorithm for Virtual Machine Instances in Cloud. International Symposium on Cloud and Services
Computing, 15–20.
[25] Gutierrez-Garcia, JO. and Ramirez-Nafarrate, A. (2015). Agent-based load balancing in Cloud data
centers. Cluster Computing, 18(3):1041–1062.
[26] Apostu, A. and Puican, F., Ularu,G., George Suciu,G., and Todoran, G. (2013). Study on advantages
and disadvantages of cloud computing – the advantages of telemetry applications in the cloud. Recent
Advances in Applied Computer Science and Digital Services.
[27] Hwang, K. and Fox, GC., and Dongarra, JJ. (2012). Distributed and Cloud Computing From Parallel
Processing to the Internet of Things. Elsevier.
[28] Kansal, NJ. and Inderveer Chana, I. (2012). Cloud Load Balancing Techniques: A Step Towards
Green Computing. International Journal of Computer Science Issues, 9(1), 238-246.
[29] Alakeel, AM. (2010). A Guide to Dynamic Load Balancing in Distributed Computer Systems.
International Journal of Computer Science and Network Security (IJCSNS), 10(6), 153-160.
[30] Yahaya, B. and Latip, R., Othman, M., and Abdullah, A. (2011). Dynamic Load Balancing Policy
with Communication and Computation Elements in Grid Computing with Multi-Agent System
Integration. International Journal on New Computer Architectures and Their Applications (IJNCAA),
1(3), 757-765.
[31] Mukhopadhyay, R. and Ghosh, D., and Mukherjee, N. (2010). A Study On The Application Of
Existing Load-balancing algorithms For Large, Dynamic, and Heterogeneous Distributed Systems. ACM:
pp. 238-243
[32] Ray, S. and Sarkar, AD. (2012). Execution Analysis of Load-balancing algorithms in Cloud
Computing Environment. International Journal on Cloud Computing: Services and Architecture
(IJCCSA), 2(5).
[33] Sidhu, AK. And Kinger, S. (2013). Analysis of Load Balancing Techniques in Cloud Computing.
International Journal of Computers and Technology, 4(2).
[34] Rathore, N. and Chana, I. (2013). A Sender Initiate Based Hierarchical Load Balancing Technique
for Grid Using Variable Threshold Value. Signal Processing, Computing and Control (ISPCC), IEEE
International Conference.
[35] Rathore, N., Channa, I. (2011). A Cognitive Analysis of Load Balancing and job migration
Technique in Grid. World Congress on Information and Communication Technologies (WICT), P. 77-82.
[36] Milani, AS. And Navimipour,NJ. (2016). Load balancing mechanisms and techniques in the cloud
environments: Systematic literature review and future trends. Journal of Network and Computer
Applications, 71, 86–98.
[37] Ahmad, RW. And Gani, A., Hamid, SHA., and Shiraz, M. (2015). A survey on virtual machine
migration and server consolidation frameworks for cloud data centers. Journal of Network and Computer
Applications. 52, 11–25.
[38] Vasic, N. and Barisits, M., and Salzgeber, V. (2009). Making Cluster Applications Energy-Aware”,
In ACDC ’09: Proceedings of the 1st Workshop on Automated Control for Datacenters and Clouds,
ACM, New York, NY, USA, pp. 37–42.
[39] Koomey, JG. (2008). Worldwide Electricity Used in Datacenters. Environmental Research Letters,
3(3):034008.
[40] Hefny, HA. and Khafagy, MH., and Ahmed, MW. (2014). Comparative Study Load Balance
Algorithms for MapReduce environment. International Journal of Applied Information Systems (IJAIS),
106(18), 41.
[41] Chethana, R., Neelakantappa, BB., and Ramesh, B. (2016). Survey on Adaptive Task Assignment in
Heterogeneous Hadoop Cluster. IEAE International Journal of Engineering, 1(1).
[42] Dsouza, MB. (2015). A Survey of Hadoop MapReduce Scheduling Algorithms. International Journal
of Innovative Research in Computer and Communication Engineering, 3(7).
[43] Valvåg, SV., (2011). Cogset: A High-Performance MapReduce Engine. p. 14, Faculty of Science and
Technology Department of Computer Science, University of Tromsö.
[44] Sui, Z. and Pallickara, S. (2011). A Survey of Load Balancing Techniques for Data Intensive
Computing. In Borko Furht and Armando Escalante, editors, Handbook of Data Intensive Computing,
pages 157–168. Springer New York.
[45] Lin, CY. and Lin, YC. (2015). A Load-Balancing Algorithm for Hadoop Distributed File System”,
18th International Conference on Network-Based Information Systems.
[46] Destanoğlu, O. and Sevilgen, FE. (2008). Randomized Hydrodynamic Load Balancing Approach”,
IEEE International Conference on Parallel Processing, 1, 196-203.

[47] Ahmad, F. and Chakradhar,ST., Raghunathan,A., and Vijaykumar, TN. (2012). Tarazu: optimizing
mapreduce on het-erogeneous clusters. International Conference on Architectural Support for
Programming Languages and Operating Systems (ASPLOS). 40(1), 61-74.
[48] Polato, I. and Re, R. Goldman, A., and Kon, F. (2014). A comprehensive view of Hadoop research
– A systematic literature review. Journal of Network and Computer Applications, 46, 1 – 25.
[49] Valvåg, SV. And Johansen, D. (2009). Cogset: A unified engine for reliable storage and parallel
processing”, Sixth IFIP International Conference on Network and Parallel Computing, 174–181.
[50] Vernica, R. and Balmin, A., Beyer, KS., and Ercegovac, V. (2012). Adaptive MapReduce using
situation-aware mappers. International Conference on Extending Database Technology (EDBT), 420–
431.
[51] Kolb, L. and Thor, A. , and Rahm, E. (2011). Block-based Load Balancing for Entity Resolution
with MapReduce. International Conference on Information and Knowledge Management (CIKM), 2397–
2400.
[52] Hsueh, SC. and Lin, MY., and Chiu, YC. (2014). A Load-Balanced MapReduce Algorithm for
Blocking-based Entity-resolution with Multiple Keys. Parallel and Distributed Computing(AusPDC),p. 3.
[53] Zaharia, M. (2009). Job Scheduling with the Fair and Capacity Schedulers. Berkley University, In
Hadoop Summit. Vol. 9.
[54] Manjaly, JS. and A, CE. (2013). Relative Study on Task Schedulers in Hadoop MapReduce.
International Journal of Advanced Research in Computer Science and Software Engineering, 3(5).
[55] Patel, HM. (2015). A Comparative Analysis of MapReduce Scheduling Algorithms for Hadoop.
International Journal of Innovative and Emerging Research in Engineering, 2(2).
[56] Li, R. and Hu, H., Li, H., Wu, Y·, and Yang, J. (2015). MapReduce Parallel Programming Model:
A State-of-the-Art Survey. International Journal of Parallel Programming, 1-35.
[57] Vaidya, M. (2012). Parallel Processing of cluster by Map Reduce. International Journal of
Distributed and Parallel Systems (IJDPS), 3(1).
[58] Dagli, MK. and Mehta, BB. (2014). Big Data and Hadoop: A Review. International Journal of
Applied Research in Engineering and Science, 2(2), pp. 192.
[59] Gautam, JV., Prajapati, HB., Dabhi, VK., and Chaudhary, S. (2015). A Survey on Job Scheduling
Algorithms in Big Data Processing. IEEE International Conference on Electrical, Computer and
Communication Technologies (ICECCT’ 15), 1-11.
[60] Khalil, S., Salem, SA., Nassar, S., and Saad, EM., (2013). Mapreduce Performance in
Heterogeneous Environments: A Review. International Journal of Scientific & Engineering Research,
4(4), 410-416.
[61] Lee, KH. , Choi, H., and Moon, B. (2011). Parallel Data Processing with MapReduce: A Survey.
SIGMOD Record, 40 (4), 11-20.
[62] Xia, Y., Wang, L., Zhao, Q., and Zhang, G. (2011). Research on Job Scheduling Algorithm in
Hadoop. Journal of Computational Information Systems, 7, 5769–5775.
[63] Zaharia, M., Konwinski, A., Joseph, AD., Katz, R., and Stoica, I. (2008). Improving MapReduce
Performance in Heterogeneous Environments. Proceedings of the 8th conference on Symposium on
Opearting Systems Design and Implementation, 29–42.
[64] Kc, K. and Anyanwu, K. (2010). Scheduling Hadoop Jobs to Meet Deadlines. In 2nd IEEE
International Conference on Cloud Computing Technology and Science (CloudCom), 388 –392.
[65] Selvi, RT. And Aruna, R. (2016). Longest Approximate Time to End Scheduling Algorithm in
Hadoop Environment. International Journal of Advanced Research in Management, Architecture,
Technology and Engineering (IJARMATE), 2(6).
[66] Zaharia, M., Borthakur, D., and Sarma, JS. (2010). “Delay Scheduling: A Simple Technique for
Achieving Locality and Fairness in Cluster Scheduling”, in Proceedings of the European conference on
Computer systems (EuroSys’10), 265–278.
[67] Fadika, Z., Dede, E., and Govidaraju, M. (2011). Benchmarking MapReduce Implementations for
Application Usage Scenarios. In Proceedings of the 2011 IEEE/ACM 12th International Conference on
Grid Computing, 0, 90– 97.
[68] Hou, X., Kumar, A., and Varadharajan, V. (2014). Dynamic Workload Balancing for Hadoop
MapReduce. Proceeding of International Conference on Big data and Cloud Computing, 56-62.
[69] Doulkeridis, C. and Nørvåg, K. (2013). A survey of large-scale analytical query processing in
MapReduce. The VLDB Journal, 1-26.
[70] Kolb, L., Thor, A., and Rahm, E. (2012). Load Balancing for MapReduce-based Entity Resolution”,
IEEE 28th International Conference on Data Engineering, 618-629.
[71] Kabir, MS.,Kabir KM., and Islam, R. (2015). Process of Load Balancing in Cloud Computing using
Genetic Algorithm. Electrical and Computer Engineering: An International Journal (ECIJ), 4(2).
[72] Nishant, K., Sharma, P., Krishna, V., Gupta, C., Singh, KP., Nitin, N., and Rastogi,R. (2012). Load
Balancing of Nodes in Cloud Using Ant Colony Optimization. 14th International Conference on
Modelling and Simulation, 3-8.
[73] Babu, LDD. and Krishna, PV. (2013). Honey bee behavior inspired load balancing of tasks in cloud
computing environments. Applied Soft Computing, 13 (5), 2292– 2303.
[74] Yakhchi, M., Ghafari, SM., Yakhchi, S., Fazeliy, M., Patooghi, A. (2015). Proposing a Load
Balancing Method Based on Cuckoo Optimization Algorithm for Energy Management in Cloud
Computing Infrastructures. Published in: 6th International Conference on Modeling, Simulation, and
Applied Optimization (ICMSAO).
[75] Shadkam, E. and Bijari, M. (2014). Evaluation the Efficiency of Cuckoo Optimization Algorithm.
International Journal on Computational Sciences & Applications (IJCSA), 4(2), 39-47.
[76] Rajabioun, R. (2011). Cuckoo Optimization Algorithm. Applied Soft Computing, 11, 5508-5518.
[77] Keshvadi, S. and Faghih, B. (2016). A Multi-Agent based Load balancing System in IaaS Cloud
Environment. International Robotics and Automation Journal, 1(1).
[78] Sim, KM. (2011). Agent-based Cloud Computing. IEEE Transactions on Services Computing, 5(4),
564-577.
[79] Tasquier, L. (2015). Agent Based Load-balancer for Multi-Cloud Environments. Columbia
International Publishing Journal of Cloud Computing Research, 1(1), 35-49.
[80] Singh, P., Baaga, P., and Gupta, S. (2016). Assorted Load-balancing algorithms in Cloud
Computing: A Survey”, International Journal of Computer Applications, 143(7).
[81] Domanal, SG. and Reddy, GRM. (2015). Load Balancing in Cloud Environment using a Novel
Hybrid Scheduling Algorithm. IEEE International Conference on Cloud Computing in Emerging
Markets, 37-42.
[82] Komarasamy, D. and Muthuswamy, V. (2016). A Novel Approach for Dynamic Load Balancing
with Effective Bin Packing and VM Reconfiguration in Cloud. Indian Journal of Science and Technology,
9(11), 1–6.
[83] Chien, NK., Son, NH., and HD. (2016). Load-balancing algorithm Based on Estimating Finish Time
of Services in Cloud Computing, International Conference on Advanced Commutation Technology
(ICACT), 228-233.
[84] Kulkarni, AK. and B, A. (2015). Load-balancing strategy for Optimal Peak Hour Performance in
Cloud Datacenters. IEEE International Conference on Signal Processing, Informatics, Communication
and Energy Systems (SPICES).
[85] Kumar, S. and Rana, DH. (2015). Various Dynamic Load-balancing algorithms in Cloud
Environment: A Survey. International Journal of Computer Applications, 129(6).
[86] Rao, BT. and Reddy, LSS. (2011). Survey on Improved Scheduling in Hadoop MapReduce in Cloud
Environments. International Journal of Computer Applications, 34(9).
[87] Goyal, S. and Verma, MK. (2016). Load Balancing Techniques in Cloud Computing Environment:
A Review. International Journal of Advanced Research in Computer Science and Software Engineering,
6(4).
[88] Farrag, AAS. and Mahmoud, SA. (2015). Intelligent Cloud Algorithms for Load Balancing
problems: A Survey. IEEE Seventh International Conference on Intelligent Computing and Information
Systems (ICICIS 'J 5), 210-216.
[89] Wei. X., Fan, J., Wang,T., and Wang, Q. (2015). Efficient application scheduling in mobile cloud
computing based on MAX–MIN ant system. Soft Computing, 1-15.
[90] Wei, X., Fan, J., Lu, Z., and Ding, K. (2013). Application Scheduling in Mobile Cloud Computing
with Load Balancing. Journal of Applied Mathematics, 1-13.
[91] Deye, MM., Slimani, Y., and sene, M. (2013). Load Balancing approach for QoS management of
multi-instance applications in Clouds. Proceeding on International Conference on Cloud Computing and
Big Data, 119-126.
[92] Sarood, O., Gupta, A., Kale, LV. (2012). Cloud Friendly Load Balancing for HPC Applications:
Preliminary Work. International Conference on Parallel Processing Workshops, 200 –205.
[93] Shen, H., Sarker, A., Yuy, L., and Feng Deng, F. (2016). Probabilistic Network-Aware Task
Placement for MapReduce Scheduling. IEEE International Conference on Cluster Computing.
[94] Scharf, M., Stein, M., Voith,T., and Hilt, V. (2015). Network-aware Instance Scheduling in
OpenStack. International Conference on Computer Communication and Network (ICCCN), 1-6.
[95] Shen, H., Yu, L., Chen,L., and Li, Z. (2016). Goodbye to Fixed Bandwidth Reservation: Job
Scheduling with Elastic Bandwidth Reservation in Clouds. International Conference on Cloud
Computing Technology and Science.
[96] Kliazovich, D., Pecero, JE., Tchernykh, A., Bouvry, P., Khan, SU., and Zomaya, AY. (2016).
CA-DAG: Modeling Communication-Aware Applications for Scheduling in Cloud Computing. Journal of
Grid Computing, 1-17.
[97] Ghosh, S. and Banerjee, C. (2016). Priority Based Modified Throttled Algorithm in Cloud
Computing. International Conference on Inventive Computation Technology.
[98] Jaikar, A., Dada, H., Kim, GR., and Noh, SY. (2014). Priority-based Virtual Machine Load
Balancing in a Scientific Federated Cloud. IEEE 3rd International Conference on Cloud Computing.
[99] Moschakisa, IA. and Karatzaa, HD. (2015). Multi-criteria scheduling of Bag-of-Tasks applications
on heterogeneous interlinked Clouds with Simulated Annealing. Journal of Software and Systems, 101:1–
14
[100] Cai, Z., Li, X., Ruizc, R., and Lia, Q. (2017). A delay-based dynamic scheduling algorithm for
bag-of-task workflows with stochastic task execution times in clouds. Journal of Future Generation
Computer Systems,71, 57-72.
[101] Cinque, M., Corradi, A., Luca Foschini,L., Frattini, F., and Mol, JP. (2016). Scalable Monitoring
and Dependable Job Scheduling Support for Multi-domain Grid Infrastructures. Proceedings of the 31st
Annual ACM Symposium on Applied Computing.
[102] Bellavista, P., Cinque, M., Corradi, A., Foschini, L., Frattini, F., and Molina, JP. (2016).
GAMESH: A grid architecture for scalable monitoring and enhanced dependable job scheduling. Future
Generation Computer Systems.
[103] Kianpisheh, S., Charkari, NM., and Kargahi, M. (2016). Ant colony based constrained workflow
scheduling for heterogeneous computing systems. Cluster Computing, 19, 1053–1070.
[104] Zhang, Y. and Li, Y. (2015). An improved Adaptive workflow scheduling Algorithm in cloud
environments. Third International Conference on Advanced Cloud and Big Data, 112-116.
[105] Yang, SJ. and Chen, YR. (2015). Design adaptive task allocation scheduler to improve MapReduce
performance in heterogeneous clouds. Journal of Network and Computer Applications, 57, 61–70.
[106] Bok, K., Hwang, J., Jongtae Lim, J., Kim, Y., and Yoo, J. (2016). An efficient MapReduce

scheduling scheme for processing large multimedia data. Multimedia Tools and Applications,1-24.

[107] Ghoneem, M. and Kulkarni, L. (2016). An Adaptive MapReduce Scheduler for Scalable
Heterogeneous Systems. Proceeding of the International Conference on Data Engineering and
Communication Technology, 603-6011.
[108] Benifa, JVB. and Dejey (2017). Performance Improvement of MapReduce for Heterogeneous
Clusters Based on Efficient Locality and Replica Aware Scheduling (ELRAS) Strategy. Wireless
Personal Communications, 1-25.

Amir Masoud Rahmani received his BS in Computer Engineering from Amir Kabir University,
Tehran, in 1996, the MS in Computer Engineering from Sharif University of Technology,
Tehran, in 1998 and the PhD degree in Computer Engineering from IAU University, Tehran, in
2005. Currently, he is a Professor in the Department of Computer Engineering at the IAU
University. He is the author/co-author of more than 150 publications in technical journals and
conferences. His research interests are in the areas of distributed systems, ad hoc and wireless
sensor networks and evolutionary computing.

Dr. Nooruldeen Nasih Qader began his new role as the Dean of College of Science and
Technology at the University of Human Development on 2009. Dr. Qader previously served as a
Lecturer at the University of Sulaimani in Iraq. He is a Senior Member of the Institute of
Electrical and Electronics Engineers (SMIEEE). He was a head of committee of IEEE election in
Iraq 2014. His Research Interests are Database Management System, Data Mining, Data
Warehouse, Bioinformatics and Information Security.