Content uploaded by Umamaheswari Kandaswamy
Author content
All content in this area was uploaded by Umamaheswari Kandaswamy on Mar 13, 2017
Content may be subject to copyright.
I
nt. J. Advanced Intelligence Paradigms, Vol. 9, Nos. 2/3, 201
7
139
Copyright © 2017 Inderscience Enterprises Ltd.
Performance comparison of discrete particle swarm
optimisation and shuffled frog leaping algorithm in
multiprocessor task scheduling problem
S. Sarathambekai* and K. Umamaheswari
Department of Information Technology,
PSG College of Technology,
Coimbatore,641 004, Tamilnadu, India
Email:vrs070708@gmail.com
Email: ssi@ity.psgtech.ac.in
Email:umakpg@gmail.com
Email: uma@ity.psgtech.ac.in
*Corresponding author
Abstract: Particle swarm optimisation (PSO) and Shuffled frog leaping (SFL)
are Swarm Intelligence (SI) based algorithms. SI algorithms are stochastic
based optimisation techniques that imitate process inspired from nature. This
paper presents a comparative performance of two recent SI based optimisation
algorithms such as discrete PSO (DPSO) and SFL in task scheduling problem.
Task scheduling (TS) is a complex combinatorial optimisation problem and
known to be NP-hard. It is an important challenging issue in distributed
systems. Make span, mean flow time and reliability cost are performance
criteria used to evaluate the efficiency of the DPSO and SFL algorithms for
scheduling independent tasks in distributed systems. Computational
simulations are done based on a set of benchmark instances to assess the
performance of the algorithms.
Keywords: distributed systems; particle swarm optimisation; shuffled frog
leaping; swarm intelligence; task scheduling.
Reference to this paper should be made as follows: Sarathambekai, S. and
Umamaheswari, K. (2017) ‘Performance comparison of discrete particle swarm
optimisation and shuffled frog leaping algorithm in multiprocessor task
scheduling problem’, Int. J. Advanced Intelligence Paradigms, Vol. 9, Nos. 2/3,
pp.139–163.
Biographical notes: S. Sarathambekai is an Assistant Professor (Senior Grade)
in the Department of IT, PSG College of Technology, Coimbatore, Tamilnadu,
India. She received her MTech (IT) in 2010. She is currently pursuing her PhD
in the field of evolutionary computation. Her areas of interest include
distributed systems, swarm intelligence, web technologies and algorithm
design.
K Umamaheswari is a Professor in the Department of IT, PSG College of
Technology, Coimbatore, Tamilnadu, India. She received her PhD in 2010. Her
research areas include classification techniques in data mining and other areas
of interest are information retrieval, software engineering, theory of
computation and compiler design. She has published more than 50 papers in
international, national journals and conferences. She is the Editor for National
Journal of Technology, PSG College of Technology and reviewer for many
national and international journals.
140 S. Sarathambekai and
K
. Umamaheswari
1 Introduction
Evolutionary computation is a sub field of computational intelligence. This is broadly
categorised into two types of algorithms such as evolutionary algorithms (EA) and swarm
intelligence (SI). EA mimics the biological evolution based on survival of the fittest.
Genetic algorithms (GA) (Omara and Arafa, 2010), evolutionary programming (EP)
(Fogel and Fogel, 1996), evolutionary strategies (ES) (Greenwood et al., 1994) and
genetic programming (GP) (Jakobovic and Budin, 2006) are some of the EA for task
scheduling problems. SI inspired by the collective intelligence that is the teamwork of
more numbers of identical agents such as fish schooling, birds flocking and colonies of
ants in the environment. PSO (Wang et al., 2014), SFL (Yang et al., 2011) and ant colony
optimisation (Ding et al., 2013) are some of the SI for task scheduling problems.
GA (Zhao et al., 2009; Singh and Kalra, 2014; Zhu et al., 2010) is a well-known EA
for independent task scheduling problems in the literature. Compared with GA, PSO
contains actually two populations (Chen and Montgomery, 2013): personal bests
(population of personal best positions which store the best found solutions) and current
positions (population of current positions which search for better solutions). This permits
PSO to achieve better diversity and exploration than GA (single population). PSO does
not have selection and crossover operators because particles are semi-autonomous agent
that decides to change their status toward the best position achieved by the particle in
their swarm. But genes in GA do not have any capabilities for sensing their surrounding
environment. So, it needs the operators to select and combine the genes toward the next
generation of population. Therefore, the computational complexity of GA is higher than
PSO.
Initially, GA is a discrete optimisation algorithm that is also suitable for
combinatorial problems and PSO is a continuous technique that is weakly suited to
discrete problems. Task scheduling (TS) is the combinatorial optimisation problem
because it has discrete decision variables (e.g.: Task number or processor number). The
classical PSO cannot be directly used in the TS problem because their positions are
continuous values. Recently, many researchers proposed different conversion techniques
such as smallest position value (SPV), Ranked-Order-Value (ROV) and truncation of the
real values for mapping continuous positions of particles in PSO to discrete values (Kaur
and Tiwari, 2012). Hence, the PSO spends more computational time for mapping values
from continuous to discrete and vice versa. To save the computational time, the velocity
and position update methods in PSO are redefined to operate directly in a discrete domain
namely DPSO (Senthilnath et al., 201; Izakian et al., 2010; Kang and He, 2011).
Senthilnath et al. (2013) demonstrated the efficiency of multi-objective DPSO
algorithm compared with RANSAC in multi-sensor image registration for matching the
feature points between the multi-sensor images. Hesam et al. (2010) proposed multi-
objective DPSO approach for grid job scheduling problem to minimise make span and
flow time. In this paper, the author redefined the velocity and position updating equations
for both direct particle representation (position vector) and indirect particle representation
(position matrix). Kang and He (2011) developed a new position update method for a
particle that is represented in position vector format in DPSO for scheduling of
Performance comparison of discrete particle
s
warm optimisation 141
meta-tasks in distributed systems to minimise the single objective that is make span.
Also, the author applied variable neighbourhood descent algorithm and migration
mechanism to escape DPSO from premature convergence problem. It also used to
balance the exploration and exploitation in DPSO (Kang and He, 2011).
Elbeltagi et al. (2005) analysed the formulation and results of five evolutionary
computation algorithms: GA, memetic algorithm (MA), PSO, ACO, and SFL. Finally,
the author (Elbeltagi et al., 2005) presented that the PSO is significantly provide better
performance than other algorithms with respect to success rate and solution quality and
also presented the SFL algorithm gives fast convergence speed because it combines the
benefits of both the genetic-based MA and the social behaviour-based PSO algorithm.
Senthilnath (2014) illustrated the performance evaluations of nature-inspired techniques:
GA, PSO and firefly algorithm (FA) in satellite image registration and concluded that
nature-inspired techniques are accurate and reliable than the traditional techniques in
satellite image registration.
Li et al. (2010) proposed grouping shuffling particle swarm optimisation (GSPSO) by
hybridising PSO and SFL algorithms. The author (Li et al., 2010) demonstrated that the
GSPSO has faster convergence speed and higher convergence precision than the PSO and
SFL. Samuel and Rajan (2015) presented a hybrid PSO based GA and hybrid PSO based
SFL algorithms for solving long-term generation maintenance scheduling problem. The
author (Samuel and Rajan, 2015) recommended hybrid PSO based SFL algorithm gives
the better solution quality, robust, cost-effective and consumes minimum computation
time for scheduling of thermal units than hybrid PSO based GA. The overview of the
related work for task scheduling problem using SI is presented in Table 1. The last
column in Table 1 indicates the neighbourhood structure which affects the performance
of SI algorithms significantly, because it determines the rate at which information
transmits through the swarm. The neighbourhood structure is classified into two types:
global best (Gbest) model and local best (Lbest). The neighbourhood of a particle is the
entire swarm (fully connected topology) then the best position in the neighbourhood is
called Gbest particle otherwise (smaller neighbourhoods are used: ring, star, Von
Neumann and tree) called Lbest particle.
From Table 1, the most of the work use PSO algorithm for task scheduling problem.
PSO is a well-known population based SI algorithm. SFL is also a famous SI algorithm,
which is an improved version of PSO (Eusuffm and Lansey, 2003). The majority of the
work in the literature perform random initialisation, LDI based inertia and Gbest model
for particle communication. Therefore, this paper presents a modified version of DPSO
algorithm which comprises heuristics based initialisation, hamming distance based inertia
weight and heap tree based particle communication for task scheduling problem. The
performance of modified DPSO is compared with an improved version of PSO called
SFL algorithm. Also, the paper presents a hybrid version of modified DPSO with SFL for
scheduling independent tasks in multiprocessor systems. The performance of the
algorithms are evaluated by the objectives makespan, mean flow time and reliability cost.
The remainder of the paper is organised as follows: Section 2 describes the problem
formulation. The Swarm Intelligence algorithms are presented in Section 3. Simulation
results are reported in Section 4. Finally, Section 5 concludes the paper.
142 S. Sarathambekai and
K
. Umamaheswari
Table 1 Swarm intelligence algorithm for task scheduling problem
Author Algorithm Initialisation Inertia weight
Neighbourhood
structure
Wang et al.
(2014)
PSO Random Random inertia weight Gbest model
(Mesh)
Yang and Sun
(2011)
SFL Random N/A Gbest model
(Mesh)
Ding et al.
(2013)
ACO Random N/A Gbest model
(Mesh)
Chen et al.
(2013)
PSO Random No inertia weight,
constriction factor included
Lbest model
(Ring)
Kaur and
Tiwari (2012)
PSO Random Linearly decreasing inertia
weight (LDI)
Gbest model
(Mesh)
Izakian et al.
(2010)
DPSO Random No inertia weight Gbest model
(Mesh)
Kang and He
(2011)
DPSO Random Linearly decreasing inertia
weight (LDI)
Gbest model
(Mesh)
2 Problem formulation
2.1 Task model
A multiprocessor system consists of a number of heterogeneous processor elements (PEs)
connected with a mesh topology. Let T = {T1, T2…, Tn} denote the n number of tasks that
are independent of each other to be scheduled on m processors P = {P1, P2..., Pm}. The TS
problem is formulated based on the following assumptions:
• all tasks are available at zero time.
• processors are always available.
• the execution time of each task on each processor is known and constant.
• preemption is not allowed.
• each processor can process only one task at a time.
• a task cannot be processed on more than one processor at a time.
• each processor uses the first-come, first-served (FCFS) method for performing the
received tasks.
2.2 ETC model
The heterogeneous nature of the processors and disparate nature of the tasks, the expected
execution times of a task executing on different processors are different. Every task has
an expected time to compute (ETC) on a specific processor. The ETC values are assumed
Performance comparison of discrete particle
s
warm optimisation 143
to be known in advance. An ETC matrix is n × m matrix in which m is the number of
processors and n is the number of tasks. One row of the ETC matrix represents estimated
execution time for a specified task on each PE. Similarly, one column of the ETC matrix
consists of the estimated execution time of a specified PE for each task. An illustrative
example for the ETC model with 5 tasks and 3 processors is shown in Figure 1.
Figure 1 ETC model for 5 × 3 (five tasks and three processors)
3 Swarm intelligence algorithms
A brief description of modified DPSO, SFL and hybrid algorithm are presented in the
following sections.
3.1 Modified discrete particle swarm optimisation
The modified DPSO incorporates the following modifications into DPSO algorithm to
improve the efficiency of the algorithm, namely intelligent heap DPSO (IHDPSO). The
flow diagram of the IHDPSO is given in Figure 2.
• heuristic based initialisation called intelligent initialisation (the two heuristics are
open path opposition and greedy load balancing)
• hamming distance based inertia weight
• heap tree (HT) based neighbourhood communication.
The following subsections describe in detail the steps involved in IHDPSO algorithm.
Figure 2 Flow diagram of IHDPSO
Construct heap
tree
No
Yes
n, m N
HIW
Open path
opposition
Greedy load
balancing
Swarm initialisation Particle evaluation
Fitness
function
Update Lbest
Update Pbest
Update velocity and
position in discrete
domain
Stopping condition
Root
node of
HT
144 S. Sarathambekai and
K
. Umamaheswari
3.1.1 Swarm initialisation
Swarm initialisation consists of two parts: particle initialisation and processor allocation.
Number of tasks (n) and population size (N) are required to generate particles. Here, a
particle is encoded in permutation based method. In the permutation vector, the position
of a task represents the sequence the task is scheduled and the corresponding value
indicates a task number.
Proper swarm initialisation may help the algorithm to explore the search space more
efficiently and detect the better solutions in the search space. Random initialisation is the
most commonly used method in majority of the evolutionary algorithms to generate
solutions in the initial population. The existing DPSO (Izakian et al., 2010; Kang and He,
2011) in the literature for task scheduling problem use random initialisation. Randomly
select the solutions from a given solution space may result in searching the unwanted
areas which may lead to fail for converging the algorithm. To address this problem,
heuristic techniques should be incorporated in IHDPSO to generate the initial swarm.
The heuristic based initialisation is explained as follows:
Initially, particle initialisation generates random particles called original swarm and
then the opponent particles of the original swarm are calculated using open path
opposition (OPO) technique (Ergezer, 2011). Now, both swarms are merged and the best
particles according to fitness function are selected to form the initial swarm for the
IHDPSO.
To make better utilisation of the processors, the IHDPSO performs load balancing
using Greedy static Load balancing algorithm (GL) (Scribe and Agarwal, 2009).
A static scheduler model in multiprocessor systems is shown in Figure 3. The
scheduler manages two queues such as task queue (TQ) and processor queue (PQ). The
scheduling algorithm in the central scheduler is started to work with TQ. TQ contains a
set of tasks in a particle. The scheduler is responsible for distributing each task in the TQ
to the individual PQ based on the workload of the each processor in the distributed
systems. Once the scheduler completes to place all the tasks from the TQ to PQ, the
processors will start executing the tasks in their own PQ.
Figure 3 Scheduling model for multiprocessor systems
3.1.2 Particle evaluation
The proposed IHDPSO algorithm is assessed by using the three evaluation criteria such
as make span (Sarathambekai and Umamaheswari, 2014), mean flow time and reliability
cost (Sarathambekai and Umamaheswari, 2014).
Performance comparison of discrete particle
s
warm optimisation 145
The value of mean flow time (Lindeke, 2005) is used to evaluate flow time. Assume k
is the total number of tasks assigned to processor Pi and Fji is the finishing time of task Tj
on a processor Pi. The calculation of mean flow time is given in equation (1).
m
i
i1
M_Flow
Mean flow time m
=
=∑ (1)
k
ji
j1
i
F
M_Flow k
=
=∑ (2)
The weighted single objective function called Constant Weighted Sum (CWS) is used to
calculate the fitness value of each particle in the swarm. This can be estimated using
equation (3).
Fitness 0.4 * Makespan 0.4 * Mean flow time *0.2 * Reliability cost=+ (3)
The performance criteria makespan and mean flow time have equal importance in
independent task scheduling problem. Hence, the weights of the makespan and mean
flow time are set to 0.4 and 0.4 respectively. If the scheduler schedules dependent tasks
then the reliability cost is an important criterion because it will consider both the link
reliability and processor reliability. In this work, the scheduler schedules the independent
tasks only. Therefore, the reliability cost is less important criterion compared to
makespan and mean flow time because it considers only the processor reliability. Hence,
the weight of the reliability cost is set to 0.2.
3.1.3 Update the particle’s personal best and local best position
The previous work of the research developed DPSO (Sarathambekai and Umamaheswari,
2014) which is based on global best (Gbest) model for task scheduling problem. In Gbest
model, all the particles will be attracted by the best particle found in the whole swarm.
Therefore, the broadcasting of the best position and fitness information is very fast. This
fast broadcasting may result in the premature convergence (local optima) problem and
also preventing further exploration (diversity) of the search space.
To reduce the premature convergence problem and improve the diversity, the
proposed IHDPSO uses local best (Lbest) model based communication instead of Gbest
model. Lbest model is constructed only with the few particles in the swarm. Hence, it
takes time for propagating information to other particles in the swarm. This slow
propagation will allow the particles to explore more areas in the search space. Therefore,
it reduces the possibility of premature convergence.
The Lbest models are star, ring, Von Neumann and tree topologies (Toscano-Pulido
et al., 2011; Reyes Medina et al., 2013). These Lbest models are static models because
the neighbouring particles are fixed throughout the algorithm’s execution. This will
decrease the diversity of the swarm. To address this problem, the dynamic Lbest model is
proposed. In this model, the neighbouring particles are defined based on the fitness value.
146 S. Sarathambekai and
K
. Umamaheswari
Therefore, the neighbouring particles are varying from iteration to iteration. This will
increase the exploration capability because it permits the particles to search solutions in
the new areas of the search space.
The proposed dynamic Lbest model is heap tree (HT) model. The worst case
complexity of HT (O (log (n))) is lower than a binary tree (O (n)). The balanced binary
trees like red black or AVL would become more complex and require more memory
compared to HT. Therefore, the computational complexity of HT is less compared to
other tree based Lbest models.
The HT based Lbest model is described as follows.
The algorithm searches the minimum fitness value in the swarm. Therefore, a heap
tree is constructed based on min-heap property (Puntambekar, 2010). In the min-heap, the
fitness value of a node (particle) is less than or equal to the fitness values of its children.
The smallest fitness value in a min-heap is at the heap’s root. The root node is affected by
the best performance of itself (only Pbest, no Lbest). The second level (or) next level
nodes is affected by the best performance found by the parent.
In min heap, the parent node is the Lbest particle of a node in the swarm. Each node
has a single parent. Therefore, there is no comparison among the neighbouring particles
(parent and children) in the min heap. In the case of binary tree, the Lbest particle of a
node is the best value among the parent and their children. An illustrative example of
finding Lbest particles of the swarm is shown in Figure 4.
In Figure 4, the fitness value of the swarm is presented in left side and the
corresponding min heap tree is presented in right side for two iterations. The velocity of
the particle 2 is affected by the particle 4 (parent node) in iteration 1 and the particle 5
(parent node) in iteration 2 due to the dynamically updation of neighbouring particles.
Figure 4 Find Lbest particle a) fitness of the swarm with size 7 b) min heap of the swarm
Iteration: 1
Particle
Number
Fitness
value
12.01
22.1
33.5
41.25
51.6
60.75
73.51
Performance comparison of discrete particle
s
warm optimisation 147
Figure 4 Find Lbest particle a) fitness of the swarm with size 7 b) min heap of the swarm
(continued)
Particle
Number
Fitness
value
12
22.01
33.5
41.21
51.2
60.7
73.01
Iteration: 2
(a)
(b)
The Pbest and the Lbest should be determined before updating the position of the
particles.
3.1.4 Updating the particle’s velocity and position
The particles in IHDPSO update their velocity and position using equation (4) and
equation (5) respectively (Scribe and Agarwal, 2009).
()
()
(t 1) ttt
11
ii ii
tt
22 i
V ( j) WV ( j) C r Pbest ( j) present ( j)
C r Lbest (j) present (j)
+=+ −
+−
(4)
( t 1) (t 1)
t
iii
p
resent ( j) present ( j) V ( j))
++
=+ (5)
where i = 1, 2, 3...N; j = 1, 2, 3...n; N is the swarm size and n is the size of particle.
• W is the inertia weight which is used to control the impact of the previous history of
velocities t
i
V on the current velocity of a given particle
• (t 1)
i
V(j)
+ is the jth element of the velocity vector of the ith particle in (t + 1)th iteration
which determines the direction in which a particle needs to move
• t
i
p
resent ( j) is jth element of ith particle in tth iteration
• r1 is the random value in range[0,1] sampled from a uniform distribution
• Mandal et al. (2010) proposed dependent random parameters to control the balance
of personal and social experiences. Therefore, r2 is set to (1–r1)
• C1 and C2 are positive constants, called acceleration coefficients which control the
influence of Personal best (Pbest) and Local best (Lbest) on the search process
148 S. Sarathambekai and
K
. Umamaheswari
• the operator –(minus) represents to find the set of swapping sequence between two
vectors (Sarathambekai and Umamaheswari, 2014)
• the operator +(plus) represents the merging operation in equation (4) and swapping
operation in equation (5) (Sarathambekai and Umamaheswari, 2014).
Linearly decreasing inertia (LDI) weight is used in the existing DPSO (Izakian et al.,
2010; Kang and He, 2011, Sarathambekai and Umamaheswari, 2014) algorithm. This
kind of the inertia factor does not guarantee that the particles have not moved away from
the local best. Instead of LDI weight, the proposed IHDPSO uses hamming distance
based inertia. Moving the particles in the IHDPSO based on the distance between the
particles and their local best that ensures that the particles have not moved away from the
local best. The Hamming inertia weight is calculated using equation (6), where W0 is the
random number between 0.5 and 1, Hi is the current hamming distance of ith particle from
the local best and MDH is the maximum distance of a particle from the local best in that
generation.
i
0
H
WW1
MDH
⎛⎞
=−
⎜⎟
⎝⎠
(6)
()
tt
ii
H Hamming distance Lbest , present= (7)
()
i
MDH Max H= (8)
3.1.5 Stopping condition
The above iterative processes on a swarm will continue until a pre-defined maximum
number of iterations have been reached or no change in the fitness value for consecutive
iterations.
3.2 Shuffled frog leaping algorithm
The population with N number of frogs is generated randomly for SFL algorithm (Zhang
et al., 2008; Sarathambekai et al., 2015). The continuous frog position values are
generated using equation (9). A frog (possible solution) contains n number of continuous
values. The n represents the number of tasks. TS is the discrete optimisation problem.
The SFL cannot be directly used in the TS problem because their positions are continuous
values. SPV conversion technique is used to find a permutation corresponding to the
continuous position Xi and then use equation (10) to make a position vector value of each
frog.
()
i min max min
X X X X * rand()=+− (9)
where Xmi n = –0.4, Xmax = 4.0, i varies from 1 to n and rand() is a uniform random
number between 0 and 1.
()
ii
PSmodm1=+ (10)
Performance comparison of discrete particle
s
warm optimisation 149
where Si is the value obtained using SPV rule, Pi is the processor number and m is the
number of processors. An illustrative example is given in Figure 5. Figure 5 illustrates the
solution representation of frog Xi for seven tasks and three processors. The SFL
algorithm is given in pseudo code 1.
Figure 5 Frog representation
Task 1 2 3 4 5 6 7
Continuous values
2.7 1.85 3.25 1.10 –0.31 -0.91 0.79
Task Permutation
6 5 7 4 2 1 3
Position Vector
1 3 2 2 3 2 1
Task 4 is assigned to Processor 2
2
Pseudo code1: Shuffled Frog Leaping
Input: Population size-N, Number of frogs in each memeplex-N1, global iteration, local
iteration
begin
Initialize the population with N number of random frogs.
for each global iteration
Evaluate each frog in the population using equation (3).
Sort the population with N frogs in descending order based on their fitness value.
Divide N into N1 memeplexes.
Determine best and worst frogs in each memeplex namely FrogLocalBest and FrogLocalWo rst
respectively.
Determine the best frog in the population namely FrogGlobalBest
for each local iteration
for each memeplex
Determine the best and worst frogs
Improve the worst frog position using equation (11) and (12)
()
i LocalBest LocalWorst
Frog position P rand()X Frog Frog=− (11)
New current i
Frog’s new position Frog Frog P=+
(12)
if FrogNew is better than Frogcurrent then
Replace Frogcurrent by FrogNew
else
Replace the FrogLo calBest by FrogGlobalBest in equation (11) and again calculate Pi and
FrogNew
if FrogNew is better than Frogcurrent then
Replace Frogcurrent by FrogNew
150 S. Sarathambekai and
K
. Umamaheswari
else
Replace Frogcurrent by randomly generated frog.
end if
end if
end for
end for
Combine the N1 memeplexes to form the population with size N.
end for
end
3.3 Hybrid algorithm
The IHDPSO integrates the leaping process of SFL (Sarathambekai et al., 2015) in the
flow of the algorithm. This algorithm is called leaping IHDPSO (LIHDPSO). LIHDPSO
divides a swarm into N1 number of memeplexes. After dividing, it finds the local best
value in each memeplex named XLB. Each memeplex constructs mesh topology for
communication among the particles. Therefore, the particles within the memeplexes
update their position based on the local best particle in their memeplex that is XLB. This
algorithm also construct heap tree for N1 number of local best XLB’s. Each XLB moves
towards parent XLB in the heap tree. The LIHDPSO algorithm is presented in
Algorithm 1.
Algorithm 1 LIHDPSO (n, N, m, N1, global iteration, local iteration)
Ste
p
1 Initialise the swarm with N number of
p
articles.
Step 2 Initialise each particle’s position and velocity.
Step 3 Evaluate the fitness of all particles in the swarm.
Step 4 Divide the swarm with size N into N1 number of memeplexes.
Step 5 Determine the particles with the best fitness within the memeplex and denote them by
XLB. And also find the best position achieved by each particle till now as the personal
best position Pbest.
Step 6 Construct a heap tree (HT) based on the fitness value of XLB and denote the root of
the HT by Xroot.
Step 7 Set the parent node of XLB is the local best particle of XLB in HT and denote them by
XLLB.
Step 8 Improve the particles in the memeplexes using the sub-steps A–D
A) Update velocity of each particle except XLB in all of the memeplexes using
equation (13).
()()
(t 1) ttt tt
11 2 2 LB
ii ii i
V WV C r Pbest present ( j) C r X present ( j)
+=+ − + − (13)
Update velocity of each XLB in all of the memeplexes using equation (14).
()()
(t 1) ttt tt
11 2 2 LLB
ii ii i
V WV C r Pbest present ( j) C r X present ( j)
+=+ − + − (14)
Update position of each particle in the memeplex using equation (15).
(t 1) (t 1)
t
iii
present ( j) present (j) V ( j)
++
=+ (15)
B)
After updating, if (t 1)
i
p
resent + is better than (t)
i
p
resent , replace the particle
Performance comparison of discrete particle
s
warm optimisation 151
(t)
i
present by the new particle (t 1)
i
present ,
+ then go to the next step; otherwise,
go to sub-step C.
C)
Check the parent node of the current particle (t)
i
present , if it is a Xroot , apply
OPO to the particle (t)
i
p
resent ; else, go to sub-step A, use the parent node’s
XLLB instead of XLB in equation (13). If the obtained particle is better than
(t)
i
p
resent , replace it; otherwise, go to sub-step D.
D)
If there is no improvement, place (t)
i
present in the external solution pool and
replace the (t)
i
p
resent in the swarm by the randomly generated feasible particle,
then go to the next step.
Step 9 Go to step 8 to update the particles in all of the memeplexes by the predefined
number of Local iterations.
Step 10 All memeplexes and the external solution pool are merged to form a swarmplus for
exchanging the information in the shuffling process. And take only the best N number
of particles from the swarmplus to form the swarm for next generation.
Step 11 If the stopping criteria is not met, go to step 4 and do the same process by the
predefined number of Global iterations.
Step 12 Output an optimal particle Xroot of LIHDPSO algorithm.
The average relative percentage deviation (RPD) (Kang and He, 2011) is also calculated
along with makespan, mean flow time and reliability cost for comparing the results of the
algorithms. It is calculated using equation (16), where P is the average result of the
proposed algorithm and ACi is the average result provided by other algorithm for each
ETC instance.
()
i
RPD AC P P *100=− (16)
4 Simulation results and analysis
The simulation results are attained using a set of ETC instances (Ali and Siegel,
2000)[31] for the distributed heterogeneous systems. The algorithms are coded in Java
and executed in Net Beans IDE.
4.1 ETC instances description
The simulation is performed on the ETC instances (Ali and Siegel, 2000) which are
categorised in 12 types of ETC’s based on three metrics: task heterogeneity, machine
heterogeneity and consistency (Kang and He, 2011).
All instances consisting of 512 tasks and 16 processors are classified into 12 different
types of ETC matrices according to the above 3 metrics.
The instances are labelled as g_a_b_c as follows:
• g means gamma distribution used in generating the matrices
• a shows the type of consistency; c – consistent, i – inconsistent, and s – semi-
consistent
152 S. Sarathambekai and
K
. Umamaheswari
• b indicates the heterogeneity of the tasks; hi – high and lo – low
• c represents the heterogeneity of the machines; hi – high and lo – low.
4.2 Parameter setup
The following parameters are initialised for simulating the algorithms.
• population size : 50
• number of iteration : 1,000
• number of local iteration: 30 for SFL (Sarathambekai et al., 2015) and LIHDPSO
• number of memeplex: 5
• the failure rate for each processor is uniformly distributed (Qin and Jiang, 2011) in
the range from 0.95×10−6 /h to 1.05×10−6/h.
The algorithms are stochastic based algorithms. Each independent run of the same
algorithm on a particular problem instance may yield a different result. To make a better
comparison of the algorithms each experiment was repeated ten times with different
random seeds and the average results are presented in the tables.
4.3 Performance comparisons
The Table 2 shows the comparison of DPSO (Kang and He, 2011) and IDPSO. IDPSO is
the incorporation of Heuristics: OPO, HGL and Hamming Inertia into DPSO. DPSO and
IDPSO use mesh topology for communication. In Table 2 and Table 3, the first column
indicates the ETC instance name, the second, third and fourth columns indicate the
makespan, mean flow time and reliability cost obtained by the algorithms. The values in
red colour indicate the better results obtained by the algorithm.
The results obtained from Table 2, The algorithm IDPSO gives better results in most
of the ETC instances compared with DPSO (Kang and He, 2011) and the IDPSO
considerably provides better performance in terms of make span by 31.47%, mean flow
time by 14.59% and reliability cost by 21.53% compared with DPSO across all ETC
instances respectively.
The proposed IHDPSO is an IDPSO with Heap topology instead of mesh topology.
The results comparison of IDPSO and IHDPSO is presented in Table 3. The algorithm
IHDPSO gives better results in majority of the ETC instances compared with
IDPSO-Mesh. From Table 3, the IHDPSO is significantly gives better performance in
terms of make span by 7.21%, mean flow time by 1.04% and reliability cost by 1.36%
compared with IDPSO-Mesh across all ETC instances respectively.
Performance comparison of three algorithms in terms of makespan, mean flow time
and reliability cost with respect to RPD are presented in Table 4, Table 5 and Table 6
respectively.
Performance comparison of discrete particle
s
warm optimisation 153
Table 2 Comparison of objective values of IDPSO with DPSO
Makespan(in seconds) Mean flow time(in seconds) Reliability cost
ETC instances
DPSO Proposed IDPSO RPD
DPSO Proposed IDPSO RPD
DPSO Proposed IDPSO RPD
c_lo_lo 36,531.98 13,430.51 172.01 15,562.19 6,795.09 129.02 0.487771 0.202651 140.69
c_lo_hi 53,500.65 30,005.22 78.31 14,995.56 14,969.91 0.17 0.447081 0.461131 –3.05
c_hi_lo 31,716.48 14,398.71 120.27 11,480.21 6,326.37 81.47 0.362982 0.191641 89.41
c_hi_hi 36,869.39 29,918.32 23.23 16,123.61 14,452.01 11.57 0.492333 0 .463532 6.21
i_lo_lo 25,372.92 29,087.83 –12.77 11,725.77 14,253.02 –17.73 0.368281 0.359362 2.48
i_lo_hi 28,745.82 31,907.83 –9.91 13,523.78 15,623.91 –13.44 0.434491 0.493252 –11.91
i_hi_lo 21,136.15 28,275.42 –25.25 84,95.42 12,177.22 –30.23 0.290152 0.412342 –29.63
i_hi_hi 30,867.93 31,858.31 –3.11 14,913.31 15,423.31 –3.31 0.458433 0.483491 –5.18
s_lo_lo 23,940.33 25,877.52 –7.49 8,712.59 11,066.11 –21.27 0.301313 0.281172 7.16
s_lo_hi 30,302.91 30,049.23 0.84 14,089.49 15,253.01 –7.63 0.445032 0.475981 –6.51
s_hi_lo 23,675.34 16,397.11 44.39 8,848.91 6,144.45 44.01 0.303032 0.203571 48.86
s_hi_hi 31,235.64 32,183.11 –2.94 15,339.87 14,975.21 2.44 0.469571 0.391863 19.83
Average 31.47 14.59 21.53
154 S. Sarathambekai and
K
. Umamaheswari
Table 3 Comparison of objective values of IHDPSO (IDPSO-Heap) with IDPSO-Mesh
Makespan(in sec) Mean flow time(in sec) Reliability cost
ETC instances Proposed
IDPSO
Proposed
IHDPSO RPD
Proposed
IDPSO
Proposed
IHDPSO RPD
Proposed
IDPSO
Proposed
IHDPSO RPD
c_lo_lo 13,430.51 13,278.11 1.15 6,795.09 6,649.38 2.19 0.202651 0.19989 1.39
c_lo_hi 30,005.22 29,724.32 0.95 14,969.91 14,968.2 0.01 0.46113 0.462185 –0.23
c_hi_lo 14,398.71 13,559.31 6.19 6,326.37 6,205.41 1.95 0.19164 0.198498 –3.45
c_hi_hi 29,918.32 20,220.55 47.96 14,452.01 14,375.6 0.53 0.46353 0.466071 –0.55
i_lo_lo 29,087.83 27,582.01 5.46 14,253.02 13,157.6 8.33 0.359362 0.31478 14.16
i_lo_hi 31,907.83 31,292.52 1.97 15,623.91 15,339.7 1.85 0.493252 0.48128 2.49
i_hi_lo 28,275.42 27,617.22 2.38 12,177.2 12,531.76 –2.83 0.412342 0.40214 2.54
i_hi_hi 31,858.31 31,174.73 2.19 15,423.31 14,535.5 6.11 0.483491 0.47713 1.34
s_lo_lo 25,877.52 25,275.82 2.38 11,066.11 11,058.9 0.07 0.28117 0.282976 –0.64
s_lo_hi 30,049.2 30,963.44 –2.95 15,253.01 15,153.3 0.66 0.475981 0.47345 0.54
s_hi_lo 16,397.11 14,289.42 14.75 6,144.45 6,585.19 –6.69 0.20357 0.217667 –6.48
s_hi_hi 32,183.11 30,964.43 3.94 14,975.21 14,936.9 0.26 0.391863 0.37252 5.19
Average 7.21 1.04 1.36
Performance comparison of discrete particle
s
warm optimisation 155
Table 4 Comparison of makespan values of IHDPSO, SFL and LIHDPSO
Makespan(in seconds)
ETC instances Proposed
IHDPSO SFL RPD
Proposed
IHDPSO
Proposed
LIHDPSO RPD SFL Proposed
LIHDPSO RPD
c_lo_lo 13,278.11 45,475.05 242.48 13,278.11 13,258.15 –0.15 45,475.05 13,258.15 242.97
c_lo_hi 29,724.32 43,807.92 47.38 29,724.32 29,865.15 0.47 43,807.92 29,865.15 46.69
c_hi_lo 13,559.31 48,087.21 254.64 13,559.31 14,796.83 9.13 48,087.21 14,796.83 224.98
c_hi_hi 20,220.55 43,237.01 113.83 20,220.55 30,074.77 48.73 43,237.01 30,074.77 43.77
i_lo_lo 27,582.01 36,566.51 32.57 27,582.01 29,656.58 7.52 36,566.51 29,656.58 23.29
i_lo_hi 31,292.52 33,918.31 8.39 31,292.52 31,228.22 –0.21 33,918.31 31,228.22 8.61
i_hi_lo 27,617.22 36,725.46 32.98 27,617.22 30,040.59 8.77 36,725.46 30,040.59 22.25
i_hi_hi 31,174.73 38,917.56 24.84 31,174.73 31,140.92 –0.11 38,917.56 31,140.92 24.97
s_lo_lo 25,275.82 45,952.53 81.81 25,275.82 25,142.11 –0.53 45,952.53 25,142.11 82.77
s_lo_hi 30,963.44 38,152.92 23.22 30,963.44 30,836.72 –0.41 38,152.92 30,836.72 23.73
s_hi_lo 14,289.42 42,693.44 198.78 14,289.42 24,095.59 68.63 42,693.44 24,095.59 77.18
s_hi_hi 30,964.43 38,377.11 23.94 30,964.43 31,655.94 2.23 38,377.11 31,655.94 21.23
Average 90.40 12.01 70.21
156 S. Sarathambekai and
K
. Umamaheswari
Table 5 Comparison of mean flow time of IHDPSO, SFL and LIHDPSO
Mean flow time (in seconds)
ETC instances Proposed
IHDPSO SFL RPD
Proposed
IHDPSO
Proposed
LIHDPSO RPD SFL Proposed
LIHDPSO RPD
c_lo_lo 6,649.38 7,690.67 15.66 6,649.38 6,750.53 1.52 7,690.67 6,750.53 13.93
c_lo_hi 14,968.21 46,059.76 207.72 14,968.21 14,885.22 –0.55 46,059.76 14,885.22 209.43
c_hi_lo 6,205.41 7,925.31 27.72 6,205.41 6,765.35 9.02 7,925.31 6,765.35 17.15
c_hi_hi 14,375.56 36,927.52 156.88 14,375.56 14,221.84 –1.07 36,927.52 14,221.84 159.65
i_lo_lo 13,157.56 29,420.15 123.59 13,157.56 14,713.89 11.83 29,420.15 14,713.89 99.95
i_lo_hi 15,339.72 34,200.14 122.95 15,339.72 15,802.21 3.01 34,200.14 15,802.21 116.43
i_hi_lo 12,531.76 26,463.02 111.17 12,531.76 12,762.88 1.84 26,463.02 12,762.88 107.34
i_hi_hi 14,535.46 31,534.13 116.95 14,535.46 15,185.69 4.47 31,534.13 15,185.69 107.66
s_lo_lo 11,058.87 22,011.27 99.04 11,058.87 12,198.58 10.31 22,011.27 12,198.58 80.44
s_lo_hi 15,153.25 24,477.81 61.54 15,153.25 15,126.41 –0.18 24,477.81 15,126.41 61.82
s_hi_lo 6,585.19 7,429.56 12.82 65,85.19 10,501.35 59.47 7,429.56 10,501.35 –29.25
s_hi_hi 14,936.89 31,519.56 111.02 14,936.89 15,146.31 1.41 31,519.56 15,146.31 108.11
Average 97.25 8.42 87.72
Performance comparison of discrete particle
s
warm optimisation 157
Table 6 Comparison of reliability cost of IHDPSO, SFL and LIHDPSO
Reliability cost(in seconds)
ETC instances Proposed
IHDPSO SFL RPD
Proposed
IHDPSO
Proposed
LIHDPSO RPD SFL Proposed
LIHDPSO RPD
c_lo_lo 0.199887 0.143201 –28.36 0.199887 0.198367 –0.76 0.143201 0.198367 –2 7.81
c_lo_hi 0.462185 0.497798 7.71 0.462185 0.459289 –0.63 0.497798 0.459289 8.38
c_hi_lo 0.198498 0.245683 23.77 0.198498 0.2090045 5.29 0.245683 0.209005 17.55
c_hi_hi 0.466071 0.491456 5.45 0.466071 0.462095 –0.85 0.491456 0.462095 6.35
i_lo_lo 0.314782 0.459408 45.94 0.31 4782 0.454084 44.25 0.459408 0.454084 1.17
i_lo_hi 0.481281 0.493489 2.54 0.481281 0.482307 0.21 0.493489 0.482307 2.32
i_hi_lo 0.402137 0.435541 8.31 0.4021 37 0.445065 10.67 0.435541 0.445065 –2.14
i_hi_hi 0.477129 0.485959 1.85 0.4771 29 0.481553 0.93 0.485959 0.481553 0.92
s_lo_lo 0.282976 0.470441 66.24 0.28 2976 0.372812 31.75 0.470441 0.372812 26.19
s_lo_hi 0.473449 0.494055 4.35 0.473449 0.467361 –1.29 0.494055 0.467361 5.71
s_hi_lo 0.217667 0.435264 99.97 0.2176 67 0.351664 61.56 0.435264 0.351664 23.77
s_hi_hi 0.372517 0.497851 33.64 0.372517 0.482579 29.55 0.497851 0.482579 3.16
Average 22.62 15.06 5.67
158 S. Sarathambekai and
K
. Umamaheswari
From Table 4 to Table 6, the algorithm IHDPSO gives better results in majority of the
ETC instances compared with SFL (Sarathambekai et al., 2015) and LIHDPSO. The
IHDPSO notably gives better performance than SFL (Scribe and Agarwal, 2009) and
LIHDPSO by 90.40% and 12.01% in terms of make span, 97.25% and 8.42% in terms of
mean flow time, 22.62% and 15.06% in terms of reliability cost across all ETC instances
respectively. LIHDPSO significantly provides better performance than the existing SFL
by 70.21% in terms of make span, 87.72% in terms of mean flow time, 5.67% in terms of
reliability cost across all ETC instances respectively.
The proposed IHDPSO and LIHDPSO algorithms allocate the tasks to the processors
with subject to balancing the load of the processors. The following part describes the
resource utilisation (RU) (Alharbi, 2012), which is the performance criterion for the
scheduler to perform scheduling with balancing the load.
The processor utilisation is defined as the percentage of time that processor Pj is busy
during the scheduling time. The processor’s utilisation PUj for the processor P
j is
calculated using equation (17).
()
j
j
Aval P
PU for j 1 m
Makespan
==… (17)
where, Aval(Pj) is the processor’s availability time. The processor availability time is the
time when the processor Pj completes the execution of all the assigned tasks. Make span
(Samuel and Rajan, 2015) (finishing time of the newest task) computes the throughput of
the heterogeneous computing system.
The resource utilisation RU is the average of processor’s utilisation, which is
calculated using equation (18).
m
j
j1
PU
RU m
=
=∑ (18)
The RU of proposed algorithms and the existing SFL algorithm is calculated using
equation (18) and the values are plotted in Figure 6.
From Figure 6, the RU of the proposed IHDPSO and LIHDPSO algorithms are in
between 0.9 and 1 in all of the ETC instances. The average percentage of RU of
IHDPSO, LIHDPSO and
SFL is by 95.57%, 93.73% and 77.39% across all ETC instances respectively.
The following part explains the performance analysis of the proposed algorithms by
using Hypothesis test.
Hypothesis testing is an essential procedure in statistics. The Wilcoxon signed-rank
test (Levine, 2012; Derrac et al., 2011) is a non-parametric statistical hypothesis test. This
test is used in this paper to statistically compare the performance of the proposed
algorithm and other algorithms.
The following steps describe the procedure to perform the Wilcoxon signed-rank test:
Performance comparison of discrete particle
s
warm optimisation 159
Figure 6 Comparison of RU of proposed algorithms and the existing algorithm (see online
version for colours)
Resource Utilisation
ETC Instance
Step 1 Formulate the null hypothesis and alternate hypothesis.
• Null hypothesis (H0): No difference between the proposed algorithm (A) and
other algorithm (B)
0B A
H :μ μ (The mean difference is zero)=
• Alternate hypothesis (H1): The proposed algorithm (A) performs better than
other algorithm (B)
1B A
H :μ μ (The mean difference is positive)>
Step 2 Calculate the differences between B and A
Bi Ai
μμ−
where i = 1,2,…,a; a is the number of ETC instances.
Step 3 Absolute the calculated differences |μBi – μAi|, i = 1,2,…,a
Step 4 Assign the rank to the absolute differences in ascending order.
Step 5 Set W+ be the sum of the positive ranks and W− be the absolute value of the sum
of the negative ranks.
Note: Here, the proposed algorithm expects to see more higher and positive ranks
(W+ is much larger than W–).
Step 6 Set the Wilcoxon test statistic W = W+
Step 7 Find the upper critical value Wx for upper tailed one sided test from the Wilcoxon
signed-rank test table with the significance level ∝ = 0.05
Step 8 Accept H1 and reject H0 if W ≥ Wx.
Table 7 and Table 8 present the comparison of average fitness value of the proposed
algorithms with the existing SFL algorithm. These tables also explain the level of
significance of the algorithms using Wilcoxon signed rank hypothesis test.
160 S. Sarathambekai and
K
. Umamaheswari
From Table 7 and Table 8, the Wilcoxon test statistic W is 75 and 78, which are
higher to the upper critical value obtained from the Wilcoxon signed rank test table
(Levine, 2012). Hence, H0 is rejected and there is an evidence, at the 5% level of
significance, that the proposed IHDPSO performance better than LIHDPSO and
LIHDPSO performance better than SFL.
Table 7 Performance comparison of fitness value of IHDPSO with LIHDPSO with respect to
hypothesis test
ETC
instances
LIHDPSO
(B)
IHDPSO
(A)
Difference
(B–A)
Absolute
difference
Ordered
differences Rank Signed
rank
c_lo_lo 8,003.51 7,971.03 32.47 32.47 23.13 1 1
c_lo_hi 17,900.24 17,877.10 23.13 23.13 32.47 2 2
c_hi_lo 8,624.91 7,905.92 718.98 718.98 61.42 3 -3
c_hi_hi 17,718.73 13,838.53 3,880.19 3,880.19 159.27 4 4
i_lo_lo 17,748.27 16,295.89 1,452.38 1,452.38 246.56 5 5
i_lo_hi 18,812.26 18,652.99 159.27 159.27 360.39 6 6
i_hi_lo 17,121.47 16,059.67 1,061.80 1,061.80 402.41 7 7
i_hi_hi 18,530.74 18,284.17 246.56 246.56 718.98 8 8
s_lo_lo 14,936.35 14,533.93 402.41 402.41 1,061.80 9 9
s_lo_hi 18,385.34 18,446.77 -61.42 61.42 1,452.38 10 10
s_hi_lo 13,838.84 8,349.88 5,488.95 5,488.95 3,880.19 11 11
s_hi_hi 18,720.99 18,360.60 360.39 360.39 5,488.95 12 12
W+ 75
W– 3
Wilcoxon test statistic W 75
Table 8 Fitness value comparison of LIHDPSO with SFL with respect to hypothesis test
ETC
instances
LIHDPSO
(B)
IHDPSO
(A)
Difference
(B–A)
Absolute
difference
Ordered
differences Rank Signed
rank
c_lo_lo 21,266.32 8,003.5117 13,262.805 13,262.805 6,210.4411 1 1
c_lo_hi 35,947.17 17,900.24 18,046.932 18,046.932 6,667.0458 2 2
c_hi_lo 22,405.06 86,24.9138 13,780.143 13,780.143 8,154.0021 3 3
c_hi_hi 32,065.91 17,718.736 14,347.174 14,347.174 8,435.2107 4 4
i_lo_lo 26,394.76 17,748.279 8,646.4769 8,646.4769 8,646.4769 5 5
i_lo_hi 27,247.48 18,812.268 8,435.2107 8,435.2107 9,237.7706 6 6
i_hi_lo 25,275.48 17,121.477 8,154.0021 8,154.0021 9,650.0332 7 7
i_hi_hi 28,180.77 18,530.74 9,650.0332 9,650.0332 12,249.263 8 8
s_lo_lo 27,185.61 14,936.351 12,249.263 12,249.263 13,262.805 9 9
s_lo_hi 25,052.39 18,385.345 6,667.0458 6,667.0458 13,780.143 10 10
s_hi_lo 20,049.29 13,838.846 6,210.4411 6,210.4411 14,347.174 11 11
s_hi_hi 27,958.77 18,720.997 9,237.7706 9,237.7706 18,046.932 12 12
W+ 78
W– 0
Wilcoxon test statistic W 78
Performance comparison of discrete particle
s
warm optimisation 161
From the obtained results, the IHDPSO algorithm substantially provides better results
than existing SFL and proposed LIHDPSO because it uses heap tree model for
communication among the particles in the swarm. LIHDPSO considerably gives better
results than the existing SFL because of hybrid of heap tree and fully connected topology
(mesh) based communication. The algorithms are ranked based on their performance is
presented in Table 9.
Table 9 Rank of the algorithms
S. no. Algorithm Rank Topology used for communication
1 IHDPSO 1 Heap tree
2 LIHDPSO 2 Hybrid topology (heap tree and mesh)
3 SFL 3 Mesh
4 DPSO 4 Mesh
5 Conclusions
DPSO is a recently developed population based swarm intelligence technique for discrete
optimisation problems. SFL algorithm is an improved version of PSO. This paper
presents the comparative analysis of modified DPSO (IHDPSO) and an improved version
of PSO (SFL) algorithms for the task scheduling problem in heterogeneous
multiprocessor systems. The hybrid version of IHDPSO (LIHDPSO) is also presented for
the task scheduling problem. The efficiency of the algorithms are tested using the three
well-known metrics such as makespan, mean flow time and reliability cost. The
performance improvements of the algorithms are evaluated based on the RPD metric. The
simulation results confirmed that the IHDPSO algorithm remarkably provides better
performance than SFL and LIHDPSO. The obtained results demonstrated that the
construction of heap tree model for an entire swarm (IHDPSO) performs better than the
construction of heap tree model for the best particles among the memeplexes (LIHDPSO)
in the swarm.
This research work evaluated the performance of IHDPSO and LIHDPSO in static
environment for the independent task scheduling problems. The future work of the
research tests the efficiency of the proposed algorithms in dynamic environment for
scheduling of dependent tasks.
References
Alharbi, F. (2012) ‘Simple scheduling algorithm with load balancing for grid computing’, Asian
Transactions on Computers, Vol. 02, No. 02, pp.8–15.
Ali, S. and Siegel, H.J. (2000) ‘Representing task and machine heterogeneities for heterogeneous
computing systems’, Tamkang Journal of Science and Engineering, Vol. 3, No. 3,
pp.195–207.
Chen, S. and Montgomery, J. (2013) ‘Particle swarm optimization with threshold convergence’,
IEEE Congress Conference on Evolutionary Computation, pp.510–516, DOI:
10.1109/CEC.2013.6557611.
162 S. Sarathambekai and
K
. Umamaheswari
Derrac, J., García, S., Molina, D. and Herrera, F. (2011) ‘A practical tutorial on the use of
nonparametric statistical tests as a methodology for comparing evolutionary and swarm
intelligence algorithms’, Swarm and Evolutionary Computation, Vol. 1, No. 1, pp.3–18.
Ding, L., Fan, P. and Wen, B. (2013) ‘A task scheduling algorithm for heterogeneous systems using
ACO’, IEEE International Symposium on Instrumentation and Measurement, Sensor Network
and Automation (IMSNA), pp.749–751.
Elbeltagi, E., Hegazy, T. and Grierson, D. (2005) ‘Comparison among five evolutionary-based
optimization algorithms’, Elsevier – Advanced Engineering Informatics, Vol. 19 No. 1,
pp.43–53.
Ergezer, M. (2011) ‘Oppositional biogeography-based optimization for combinatorial problems’,
IEEE Congress on Evolutionary Computation, pp.1496–1503, 2011.
Eusuffm, M. and Lansey, K.E. (2003) ‘Optimization of water distribution network design using
shuffled frog leaping algorithm,’ Journal of Water Resources Planning and Management,
March, Vol. 129, No. 3, pp.210–225.
Fogel, D.B. and Fogel, L.J. (1996) ‘Using evolutionary programming to schedule tasks on a suite of
heterogeneous computers’, Journal on Computers and Operations Research, Vol. 23, No. 6,
pp.527–534.
Greenwood, G.W., Gupta, A. and McSweeney, K. (1994) ‘Scheduling tasks in multiprocessor
systems using evolutionary strategies’, IEEE World Congress on Computational Intelligence,
Vol. 1, pp.345–349.
Izakian, H., Ladani, B.T., Abraham, A. and Snasel, V. (2010) ‘A discrete particle swarm
optimization approach for grid job scheduling’, International Journal of Innovative
Computing, Information and Control, Vol. 6, No. 9, pp.1–14.
Jakobovic, D. and Budin, L. (2006) ‘Dynamic scheduling with genetic programming’,
Springer-Genetic Programming Lecture Notes in Computer Science, Vol. 3905, No. 1,
pp.73–84.
Kang, Q. and He, H. (2011) ‘A novel discrete particle swarm optimization algorithm for meta-task
assignment in heterogeneous computing systems’, Elsevier–Microprocessors and
Microsystems, Vol. 35, No. 1, pp.10–17.
Kaur, K. and Tiwari, S.P. (2012) ‘Grid scheduling using PSO with SPV rule’, International Journal
of Advanced Research in Computer Science and Electronics Engineering, Vol. 1, No. 5,
pp.20–26, 2012, ISSN: 2277–9043.
Levine, D.M. (2012) ‘E-study guide for statistics for managers using MS Excel: chapter
12.8–Wilcoxon signed ranks test: nonparametric analysis for two related populations’,
Cram101 Textbook Reviews.
Li, Y., Dong, X. and Liu, J. (2010) ‘Grouping-shuffling particle swarm optimization: an improved
PSO for continuous optimization’, Advances in Swarm Intelligence Lecture Notes in Computer
Science, Vol. 6145, No. 2, pp.86–93.
Lindeke, R. (2005) Scheduling of Jobs, IE 3265–POM, Spring [online]
http://www.docfoc.com/scheduling-of-jobs (accessed 28 June 2016).
Mandal, D., Ghoshal, S.P. and Bhattacharjee, A.K. (2010) ’Radiation pattern optimization for
concentric circular antenna array with central element feeding using craziness based particle
swarm optimization’, International Journal of RF and Microwave Computer-Aided
Engineering, Vol. 20, No. 5, pp.577–586.
Omara, F.A. and Arafa, M.M. (2010) ‘Genetic algorithms for task scheduling problem’, Journal of
Parallel and Distributed Computing, Vol. 70, No. 1, pp.13–22.
Puntambekar, A.A. (2010) ‘Data Structures (Computer Science)’, pp.57–61, Technical
Publications, Pune, India.
Qin, X. and Jiang, H. (2001) ‘Dynamic, reliability-driven scheduling of parallel real-time jobs in
heterogeneous systems’, IEEE International Conference on Parallel Processing, pp.113–122,
DOI:10.1109/ICPP.2001.952053.
Performance comparison of discrete particle
s
warm optimisation 163
Reyes Medina, A.J., Pulido, G.T. and Ramirez Torres, J.G. (2013) ‘A comparison study of PSO
neighborhoods’, Springer Series – Advances in Intelligent Systems and Computing,
Vol. 175, No. 2, pp.251–265, ISSN 2194-5357.
Samuel, G.G. and Rajan, C.C.A. (2015) ‘Hybrid: particle swarm optimization–genetic algorithm
and particle swarm optimization–shuffled frog leaping algorithm for long-term generator
maintenance scheduling’, Elsevier International Journal of Electrical Power & Energy
Systems, Vol. 65, No. 1, pp.432–442.
Sarathambekai, S. and Umamaheswari, K. (2014) ‘Task scheduling in distributed systems using
discrete particle swarm optimization’, International Journal of Advanced Research in
Computer Science and Software Engineering, Vol. 4, No. 2, pp.510–522.
Sarathambekai, S., Umamaheswari, K. and Tharanipriya, G. (2015) ‘Shuffled frog leaping
algorithm in distributed system’, International Journal of Computer Applications (IJCA):
Proceedings on International Conference on Innovations in Computing Techniques, No. 3,
pp.12–15, ISBN: 973-93-80887-73-5.
Scribe, C.C. and Agarwal, R. (2009) ‘Approximation algorithms – load balancing/multiprocessor
scheduling’, Lecture CS 598CSC, 4 February [online]
https://courses.engr.illinois.edu/cs598csc/sp2009/lectures/lecture_5.pdf (accessed 28 June
2016).
Senthilnath, B.J., Yang, X-S. and Benediktsson, J.A. (2014) ‘Automatic registration of multi-
temporal remote sensing images based on nature inspired techniques’, International Journal of
Image and Data Fusion, Vol. 5, No. 4, pp.263–284, Taylor & Francis.
Senthilnath, J., Omkar, S.N., Mani, V. and Karthikeyan, T. (2013) ‘Multiobjective discrete particle
swam optimization for multisensor image alignment’, IEEE Geoscience and Remote Sensing
Letters, Vol. 10, No. 5, pp.1095–1099, IEEE.
Singh, S. and Kalra, M. (2014) ‘Task scheduling optimization of independent tasks in cloud
computing using enhanced genetic algorithm’, International Journal of Application or
Innovation in Engineering & Management (IJAIEM), Vol. 3, No. 7, pp.286–291.
Toscano-Pulido, G., Reyes-Medina, A.J. and Ramirez-Torres, J.G. (2011) ‘A statistical study of the
effects of neighborhood topologies in particle swarm optimization’, Springer Series –Studies
in Computational Intelligence, Vol. 343, No. 1, pp.179–192, ISSN 1860-949X.
Wang, J., Li, F., Zhang, L. and Huang, Y. (2014) ‘PSO based hierarchical task scheduling with
QoS preference awareness in cloud storage environment’, Journal of Software, Vol. 9, No. 9,
pp.2393–2400.
Yang, W. and Sun, Y. (2011) ‘An improved shuffled frog leaping algorithm for grid task
scheduling’, IEEE International Conference on Network Computing and Information Security,
pp.342–346.
Zhang, L., Chen, Y., Sun, R., Jing, S. and Yang, B. (2008) ‘A task scheduling algorithm based on
PSO for grid computing’, International Journal of Computational Intelligence Research,
Vol. 4, No. 1, pp.37–43.
Zhao, C., Zhang, S. and Liu, Q. (2009) ‘Independent tasks scheduling based on genetic algorithm in
cloud computing’, International Conference on Wireless Communications, Networking and
Mobile Computing, pp.1–4.
Zhu, H., Wang, Y. and Wang, X. (2010) ‘Grid independent task scheduling multi-objective
optimization model and genetic algorithm’, Journal of Computers, Vol. 5, No. 12,
pp.1907–1915.
