1. No category

Microprocessors and Microsystems xxx (2013) xxx–xxx
Contents lists available at SciVerse ScienceDirect
Microprocessors and Microsystems
journal homepage: www.elsevier.com/locate/micpro
Modified Binary Particle Swarm optimization algorithm application
to real-time task assignment in heterogeneous multiprocessor
K. Prescilla a,⇑, A. Immanuel Selvakumar b
a
b
Department of Electronics and Communication Engineering, Karunya University, Karunya Nagar, Coimbatore 641 114, India
Department of Electrical and Electronics Engineering, Karunya University, Karunya Nagar, Coimbatore 641 114, India
a r t i c l e
i n f o
Article history:
Available online xxxx
Keywords:
Heterogeneous processors
Multiprocessors
Modified BPSO
Novel BPSO
Periodic tasks
Scheduling
Task assignment
Real-time Systems
a b s t r a c t
Task assignment in a heterogeneous multiprocessor is a NP-hard problem, so approximate methods are
used to solve the problem. In this paper the Modified Binary Particle Swarm Optimization (Modified
BPSO) algorithm and Novel Binary Particle Swarm (Novel BPSO) Optimization are applied to solve the
real-time task assignment in heterogeneous multiprocessor. The problem consists of a set of independent
periodic task, which has to be assigned to a heterogeneous multiprocessor without exceeding the utilization bound. The objective is to schedule maximum number of tasks with minimum energy consumption. The execution times and deadlines of the tasks are assumed to be known. Here Modified BPSO
performance is compared with Novel BPSO and Ant Colony Optimization algorithm (ACO). Experimental
results show that Modified BPSO performs better than Novel BPSO and ACO for consistent utilization
matrix and ACO performs better than Modified BPSO and Novel BPSO for inconsistent utilization matrix.
Ó 2013 Elsevier B.V. All rights reserved.
1. Introduction
Scheduling of task in a real-time system is important, because
many of them are implemented in critical application. Due to the
need to handle, different computationally intensive applications
that have diverse computational requirements by a real-time system, they incorporate heterogeneous multiprocessors. Multiprocessor in a real-time system consists of a number of tasks with
different deadlines. Therefore selection of an appropriate task
scheduling algorithm is central to the proper functioning of the
system. Static scheduling has the ability to consider complex
dependencies, communication delays, and resource contention
among jobs when constructing the static schedule. It also guarantees absence of deadlocks and unpredictable delays. Scheduling of
real-time tasks in multiprocessor systems can be solved by two
steps (i) Task allocation to processors and (ii) Scheduling tasks
on individual processors. Partitioning method is appropriate for
task allocation to multiprocessors, because it reduces the complex
multiprocessor scheduling into uniprocessor one. There are multiple objectives to be optimized for this problem.
A heterogeneous Multiprocessor has two or more processors
with different speed (or) memory space (or) special processing
capabilities. Task assignment in a heterogeneous multiprocessor
system is a multiobjective combinatorial optimization problem,
⇑ Corresponding author. Mobile: +91 9092412458.
E-mail addresses: [email protected] (K. Prescilla), immanuel.
[email protected] (A. Immanuel Selvakumar).
which is NP hard [1]. Since it is an NP-hard problem, it cannot be
solved within polynomial time, so approximate methods are used
to get near-optimal solutions within reasonable time. Approximate
algorithms are called heuristics [2]. In this paper, the heuristics selected to partition are Modified BPSO and Novel BPSO.
2. Problem statement
Let s, f, X represent a minimization problem of task assignment
for a heterogeneous multiprocessor system, where S represents the
set of candidate schedules, f is the objective function which assigns
an objective function value f(s) to each schedule s 2 S and X represents the constraint. The constraints are a task should be assigned
to only one processor and the total utilization of each processor
should not exceed unity. The goal is to find a globally optimal feasible solution s⁄, that is, a minimum energy feasible solution to the
minimization problem. The tasks are assigned by partitioning approach. In partitioned scheduling problem each task is assigned
to a specific processor and there is no inter-processor migration.
The off-line version of the task assignment problem is considered,
that is, determining each task’s processor assignment without
exceeding each processor’s computing capacity and violating task
deadlines. The computation times and deadlines of the given tasks
are known a prior and will not change over time. The tasks are
independent and thus there are no precedence constraints among
them. And there is no inter-task communication.
Let P = {P1, P2, . . . , Pm} denotes an arbitrary Heterogeneous Multiprocessor Platform with pre-emptive processors based on CMOS
0141-9331/$ - see front matter Ó 2013 Elsevier B.V. All rights reserved.
http://dx.doi.org/10.1016/j.micpro.2013.05.003
Please cite this article in press as: K. Prescilla, A. Immanuel Selvakumar, Modified Binary Particle Swarm optimization algorithm application to real-time
task assignment in heterogeneous multiprocessor, Microprocess. Microsyst. (2013), http://dx.doi.org/10.1016/j.micpro.2013.05.003
2
K. Prescilla, A. Immanuel Selvakumar / Microprocessors and Microsystems xxx (2013) xxx–xxx
technology. Each processor Pj is limited to operating only one
instruction per clock cycle, and runs at variable speed according
to the type of task it is performing. si,j denotes the clock frequency,
i.e., the speed, of Pj for a particular task Ti,ei,j denotes the execution
time for Ti on processor Pj. Hence, ei,j and si,j are correlated by: ei,j = ci/si,j, where ci is the number of clock cycles to execute Ti. The energy consumption of Ti on Pj per period, Ei,j, is given by:
Ei;j ¼ Power i;j ei;j C ef s3i;j
k
2
!
ei;j ¼
C ef
k
2
ci s2i;j
ð1Þ
where Cef and k are constants [3,4]. Therefore, the energy consumption incurred by executing Ti on Pj is almost linearly related to the
product of ci and s2i;j : Ei;j / ci s2i;j A Periodic Task Set T = {T1, T2, . . . , Tn} is comprised of n real-time tasks. A real-time task Ti is represented by the tuple (e, p) where is the estimated worst-case
execution time (WCET) and p is the period. Ti generates an infinite
sequence of task instances of execution time at most e time units
each, with instances being generated exactly p time units apart,
and each instance has a deadline p time units after its arrival. The
task assignment problem consists of two objectives. The first one
is called resource objective; that is, searching for a solution in which
each of the tasks is assigned to a specific processor in such a way
that the cumulative utilization of any processor does not exceed
the utilization bound of the EDF algorithm [5]. This objective represents a decision problem which is proven to be NP-hard in [6]. The
second one is called energy objective; that is, minimizing the cumulative energy consumption of all assigned tasks in a solution. The resource objective is given precedence over the energy objective.
3. Related work
Xu and Parnas [7] explained why pre-run-time scheduling is
essential if one wishes to guarantee that timing constraints will
be satisfied in a large complex hard-real-time system. Braun
et al. [8] gave a Comparison of Eleven Static Heuristics for Mapping
a Class of Independent Tasks onto Heterogeneous Distributed Computing Systems. A collection of 11 heuristics from the literature has
been selected, adapted, implemented, and analyzed under one set
of common assumptions. The objective was to minimize the makespan. Aydin and Yang [9] addressed the problem of partitioning
periodic real-time tasks in a multiprocessor platform by considering both feasibility and energy-awareness perspectives. Baruah [1]
proves that the heterogeneous multiprocessor partitioning problem is intractable (NP-hard in the strong sense). The author proposed an efficient (i.e., polynomial-time) algorithm for solving
the Task assignment problem (TAP). His algorithm6 transforms a
TAP instance into an Integer Linear Programming (ILP) problem,
and then applies an approximation technique based on the idea
of LP relaxations to solve the ILP in polynomial time. This algorithm
is guaranteed to be able to find a feasible assignment solution to
the TAP instances that meet certain constraints. Khanesar et al.
[10] proposed Novel Binary Particle Swarm Optimization algorithm. It has a new interpretation for the velocity of binary PSO.
The main difficulty of older version of binary PSO which is choosing proper value for w is solved. The previous direction and previous state of each particle is also taken into account and helped
finding good solutions for problems. Lee et al. [11] proposed Modified Binary Particle Swarm Optimization which adopts concepts of
the genotype–phenotype representation and the mutation operator of genetic algorithms. Its main feature is that the BPSO can be
treated as a continuous PSO. Chen et al. [12] presented a new algorithm based on ant colony optimization (ACO) meta-heuristic for
solving the problem of determining whether a set of periodic tasks
can be assigned to a set of heterogeneous processors without deadline violations. A local search heuristic that can be used by various
meta-heuristics to improve the assignment solution is proposed
and its time and space complexity is analyzed.
4. Binary Particle Swarm Optimization algorithms
4.1. Binary Particle Swarm Optimization (BPSO)
Particle swarm optimization (PSO) was developed in 1995 by
James Kennedy and Russell Eberhart. The PSO is a population based
search algorithm based on the simulation of the social behavior of
birds, bees or a school of fishes. PSO applies the concept of social
interaction to problem solving. It uses a number of particles that
constitute a swarm moving around in the search space looking
for the best solution. Each particle is treated as a point in a N
dimensional space which adjusts its ‘‘flying’’ according to its own
flying experience as well as the flying experience of other particles.
Each particle has fitness value and velocity directing the flight. Particles follow two current best solutions pbest and gbest. Each particle keeps track of its coordinates in the solution space which are
associated with the best solution that has achieved so far by that
particle. This value is called personal best, Pibest. Another value
tracked by the PSO is the best value obtained so far by any particle
in the neighborhood of that particle. This value is called Pgbest. The
basic concept of PSO lies in accelerating each particle toward its
pbest and the gbest locations, with a random weighted acceleration at each time step. The PSO process then is iterated a fixed
number of times or until a minimum error based on desired performance index is achieved. In the binary PSO, the particle’s personal
best and global best is updated as in real-valued version. The major
difference between binary PSO with real-valued version is that
velocities of the particles are defined in terms of probabilities that
a bit will change to one. In binary PSO small numbers for Vmax promotes exploration. If Vmax = 0, then the search changes into a pure
random search [13].
4.2. Novel Binary Particle Swarm Optimization
In this algorithm, Pibest the and Pgbest of the swarm are updated
as in real-valued or binary version. The major difference between
this algorithm and other version of binary PSO is the interpretation
of velocity. Here, as in real-valued version of PSO, velocity of a particle is the rate at which the particle changes its bit’s value. There
are two vectors for each particle, they are: ~
V 0j and ~
V 1j . ~
V 0j is the
V 1j
probability of the bits of the particle to change to zero while ~
is the probability that bits of particle change to one. The probability
of change in jth bit of ith particle is defined as follows
(
V ci;j ¼
V 1i;j ; if xi;j ¼ 0
ð2Þ
V 0i;j ; if xi;j ¼ 1
V 0j and ~
V 1j is
V ci;j is the velocity of particle. The update algorithm for ~
shown below. Consider that the jth bit of ith best particle is one, so
to guide the bit jth of ith particle to its best position, the velocity of
change to one ð~
V 0j Þ for that particle increases and the velocity of
V 1j Þ decreases. The following rules are extracted
change to zero ð~
from this concept.
1
0
0
dij;1
1
dij;1
If Pjibest ¼ 1 then dij;1 ¼ r1 c1 and dij;1 ¼ r 1 c1
Pjibest
¼ r 1 c1
ð4Þ
If Pjgbest ¼ 1 then dij;2 ¼ r 2 c2 and dij;2 ¼ r 2 c2
ð5Þ
If
If
Pjgbest
¼ 0 then
¼ 0 then
1
¼ r 1 c1 and
ð3Þ
1
0
1
dij;2
0
dij;2
¼ r 2 c2 and
¼ r2 c2
ð6Þ
0
where dij ; dij are two temporary values, r1 and r2 are two random
variable in the range of (0, 1) which are updated in each iteration.
Please cite this article in press as: K. Prescilla, A. Immanuel Selvakumar, Modified Binary Particle Swarm optimization algorithm application to real-time
task assignment in heterogeneous multiprocessor, Microprocess. Microsyst. (2013), http://dx.doi.org/10.1016/j.micpro.2013.05.003
3
K. Prescilla, A. Immanuel Selvakumar / Microprocessors and Microsystems xxx (2013) xxx–xxx
Also c1 and c2 are two fixed variables which are determined by user.
Then:
1
1
ð7Þ
0
dij;1
0
dij;2
ð8Þ
V 1ij ¼ wV 1ij þ dij;1 þ dij;2
V 0ij
¼
wV 0ij
þ
þ
where w is the inertia term. In this algorithm if the jth bit in
the global best variable is zero or if the jth bit in the corre-
sponding personal best variable is zero the velocity V 0ij is increased. And the probability of changing to one decreases with
the same rate. In addition, if the jth bit in the global best variable is one V 1ij is increased and V 0ij decreases. In this approach
previously found direction of change to one or change to zero
for a bit is maintained and used, so particles make use of previously found direction. After updating velocity of particles, ~
V 0j
V 1j , the velocity of change is obtained as in (2). A normaland ~
Fig. 1. Flow chart of the Novel BPSO with Local search algorithm.
Please cite this article in press as: K. Prescilla, A. Immanuel Selvakumar, Modified Binary Particle Swarm optimization algorithm application to real-time
task assignment in heterogeneous multiprocessor, Microprocess. Microsyst. (2013), http://dx.doi.org/10.1016/j.micpro.2013.05.003
4
K. Prescilla, A. Immanuel Selvakumar / Microprocessors and Microsystems xxx (2013) xxx–xxx
ization process is also done. Using sigmoid function as introduced in (9).
v 0i;j ðtÞ ¼ sigðv i;j ðtÞÞ ¼ 1=1 þ ev
i;j ðtÞ
(
X ij ðt þ 1Þ ¼
X ij ðtÞ; if r ij < V 0ij
X ij ðtÞ; if r ij > V 0ij
ð10Þ
ð9Þ
And then the next particles state is computed as follows:
where X ij ðtÞ is the 2’s complement of Xij(t) (i.e.), if Xij = 0 then X ij ¼ 1
and if Xij = 1 then X ij ¼ 0. Here rij is a uniform random number
Fig. 2. Flow chart of the Modified BPSO with Local search algorithm.
Please cite this article in press as: K. Prescilla, A. Immanuel Selvakumar, Modified Binary Particle Swarm optimization algorithm application to real-time
task assignment in heterogeneous multiprocessor, Microprocess. Microsyst. (2013), http://dx.doi.org/10.1016/j.micpro.2013.05.003
5
K. Prescilla, A. Immanuel Selvakumar / Microprocessors and Microsystems xxx (2013) xxx–xxx
between 0 and 1. The inertia weight used here maintains the previous direction of bits of particle to the personal best bit or global best
bit whether it is 1 or 0. As in real-valued PSO if the maximum velocity value considered is large, random search will happen. Small values for maximum velocity cause the particle to move less [10]. Here
also the previous states of the bits of the particles are taken into account using Eq. (8).
4.3. Modified Binary Particle Swarm Optimization
The Modified BPSO is described using the genotype and phenotype concept. The velocity and the binary position parameters of
the original BPSO are corresponding to the genotype of position
and phenotype of position of the Modified BPSO, respectively.
The main difference between the PSO and the Modified BPSO is
in the position update function. The next position of the BPSO is
not influenced by the current position but influenced by the velocity only. This implies that when updating a position in the BPSO, it
is meaningless to know where a particle is currently located in the
binary search space. Because of this fact, it seems that velocity is a
particle, even though the binary position already exists in the
BPSO. In Modified BPSO, the concept is that, the velocity and the
position of the original BPSO is taken as a particle and a solution
is transformed by the sigmoid function. Let the velocity and the
binary position of the original BPSO be a genotype xg,i,j and a phenotype xp,i,j, respectively. Then, the update functions of Modified
BPSO are as follows [11]:
v i;j ðt þ 1Þ ¼ wv i;j ðtÞ þ c1
Fig. 3. The number of task assigned for the three algorithms of consistent
utilization matrix.
R1 ðpbest;i;j xp;i;j ðtÞÞ þ c2 R2 ðg best;i;j
xp;i;j ðtÞÞ
ð11Þ
where R1 and R2 are two random variable in the range of (0, 1)
which are updated in each iteration. And c1 and c2 are two fixed
variables which are determined by user. The value of c1 and c2 are
fixed to 2 in this application
xgi;j ðt þ 1Þ ¼ xgi;j ðtÞ þ v i;j ðt þ 1Þ
xpi;j ðt þ 1Þ ¼
0; if randðÞ P Sðxgi;j ðt þ 1ÞÞ
1; if randðÞ; < Sðxgi;j ðt þ 1ÞÞ
ð12Þ
ð13Þ
where
ðxgi;j ðt þ 1ÞÞ ¼ 1=1 þ exgij ðtþ1Þ
Fig. 4. The number of task assigned for the three algorithms of inconsistent
utilization matrix.
ð14Þ
5. Implementation
The algorithms are implemented on IntelÒ Core™ i3 CPU processor with 2.27 GHz processor speed and 2.87 GB usable RAM.
Nine utilization matrices are generated commonly for both Modified BPSO, Novel BPSO and ACO algorithm. The utilization matrixes differ in (i) Number of processor (ii) Number of tasks
(iii) Task heterogeneity and (iv) Processor heterogeneity. The
algorithms are implemented on IntelÒ Core™ i3 CPU processor
with 2.27 GHz processor speed and 2.87 GB usable RAM. The
software used is MATLAB 7.6.0 (R2008a). The utilization matrix
Unm stores the real numbers in the range [0–1], the value of
ui,j denotes the maximum fraction of the computing capacity Pj
of required to execute Ti. A consistent utilization matrix is generated by sorting each speed vector independently, with processor P0 always being the fastest and processor P(m1) the slowest.
In contrast, inconsistent utilization matrices simulate the situation where processor Pj may be faster than processor Pk for some
tasks and slower for others. These utilization matrices are left in
the unsorted, random state as they are generated. The utilization
matrix is created as in [12]. The quality of the solution is measured by the objective function f(s).
Table 1
normalized cumulative energy consumption of all assigned tasks in solution S by the
three algorithms.
Problem instance
Modified BPSO
Novel BPSO
ACO
C1_P4_T100_HT_HP
C2_P8_T60_HT_LP
C3_P4_T80_LT_HP
C4_P8_T50_LT_LP
IC1_P5_T150_HT_HP
IC2_P8_T60_HT_LP
IC3_P4_T100_LT_HP
IC4_P8_T60_LT_LP
IC5_P5_T20_LT_LP
0.385581
0.014091
0.000802
0.000027
1
0.000036
0.001601
0.000064
0.000003
0.350896
0.013641
0.000758
0.000027
0.990991
0.000036
0.001603
0.000065
0
0.340215
0.015264
0.000782
0.000026
0.105714
0.004701
0.001606
0.000068
0.00001
Table 2
Average CPU time consumed by the three algorithms (s) to execute different problem
instances.
Problem instance
Modified BPSO
Novel BPSO
ACO
C1_P4_T100_HT_HP
C2_P8_T60_HT_LP
C3_P4_T80_LT_HP
C4_P8_T50_LT_LP
IC1_P5_T150_HT_HP
IC2_P8_T60_HT_LP
IC3_P4_T100_LT_HP
IC4_P8_T60_LT_LP
IC5_P5_T20_LT_LP
2.886
7.781
18.416
10.596
51.367
0.429
1.962
14.609
0.187
0.741
1.346
0.585
1.369
1.79
1.229
0.706
1.47
0.285
1.346
1.965
0.9
1.379
3.19
1.705
1.105
1.482
0.44
Please cite this article in press as: K. Prescilla, A. Immanuel Selvakumar, Modified Binary Particle Swarm optimization algorithm application to real-time
task assignment in heterogeneous multiprocessor, Microprocess. Microsyst. (2013), http://dx.doi.org/10.1016/j.micpro.2013.05.003
6
K. Prescilla, A. Immanuel Selvakumar / Microprocessors and Microsystems xxx (2013) xxx–xxx
Table 3
Quality of the solution for Modified BPSO, Novel BPSO and ACO and their ranks.
S. no
Problem instance
Quality of the solution
1
2
3
4
5
6
7
8
9
Average rank
C1_P4_T100_HT_HP
C2_P8_T60_HT_LP
C3_P4_T80_LT_HP
C4_P8_T50_LT_LP
IC1_P5_T150_HT_HP
IC2_P8_T60_HT_LP
IC3_P4_T100_LT_HP
IC4_P8_T60_LT_LP
IC5_P5_T20_LT_LP
Modified BPSO
Novel BPSO
ACO
Modified BPSO
Novel BPSO
ACO
80.4541
49.5371
72.4197
41.5300
149.0343
59.4796
98.0576
58.1572
20.4567
74.5028
48.5523
67.4512
39.5271
145.0415
59.4796
96.0564
54.1496
20.6010
75.5418
48.5610
68.4553
40.5229
150.0749
60.1955
98.0493
57.1311
20.4841
1
1
1
1
2
2
1
1
3
1
3
3
3
3
3
2
3
3
1
3
2
2
2
2
1
1
2
2
2
2
ECðsÞ
f ðsÞ ¼ AwardðsÞ þ 1 MaxEC
where ECðsÞ ¼
Pm Pn
j¼1
s
i¼1 Ei;j :Di;j
Rank of the solution
; MaxEC ¼
ð15Þ
Pn
2
i¼1 ci :Maxðsi;j Þ
j ¼ 1; . . . ;
Ei;j ¼ C i :S2i;j
m and
Award(s) is equal to the number of assigned tasks in solution s.
Award(s) reflects the distance between solution s and a feasible
solution. EC(s) is the cumulative energy consumption of all assigned tasks in solution s, and is normalized by the maximum possible energy consumption MaxEC. The Novel BPSO with Local
search algorithm is implemented as shown in the Fig. 1. The Modified BPSO with Local search algorithm is implemented as shown in
the Fig. 2.
6. Result and discussion
The problem instance C1_P4_T100_HT_HP-represents first consistent matrix with four processors and 100 tasks with high task
heterogeneity
and
high
processor
heterogeneity.
IC1_P5_T150_HT_HP represents first inconsistent matrix with five
processors and 150 tasks with high task heterogeneity and high
processor heterogeneity. The number of particles for each problem
instance is considered as equal to the number of processors in that
problem instance. Each problem instance was run on Modified
BPSO algorithm and ACO algorithm until convergence and on Novel BPSO algorithm for nine iterations with varying inertia ‘w’.
For Novel BPSO algorithm, the inertia was initialized to 0.9 and it
is reduced by 0.1 for each iteration. This is done to have smooth
convergence. The number of task assigned by Modified BPSO for
problem instances of consistent utilization matrix is more when
compared to Novel BPSO and ACO implementation. The number
of task assigned by ACO for problem instances of inconsistent utilization matrix is slightly more when compared to Novel BPSO and
Modified BPSO. The performance of Modified BPSO is better than
Novel BPSO in all cases. This is because; the position update of
the Modified BPSO uses the information of the current position
and the velocity. The Novel BPSO and Modified BPSO require a
trained input to get good solutions. The input given to the Modified
BPSO Algorithm is a trained input from Ant Colony Optimization.
One of the disadvantages of BPSO is slow convergence in refined
search stage. So it requires a trained input and more number of
iterations for convergence. ACO does not require a trained input.
It is capable of training on self. So it requires less number of iterations for convergence. Fig. 3 shows the comparison between the
number of task assigned for the three algorithms of consistent utilization matrix. Fig. 4 shows the comparison between the number
of task assigned for the three algorithms of inconsistent utilization
matrix.
Energy consumed is reduced for feasible solutions by using Local Energy algorithm for all the three optimization techniques. The
CPU time taken for Modified BPSO is more compared to Novel BPSO
and ACO.
Table 1 shows the comparison between normalized cumulative
energy consumption of all as assigned tasks in solution s by the
three algorithms for different problem instances. Table 2 shows
the comparison between average CPU time consumed by the three
algorithms for different problem instances. Table 3 shows the quality of the solution and their corresponding ranks.
7. Conclusion
This work has analyzed the performance of different heuristic
algorithms, on scheduling heterogeneous multiprocessor platform.
The major contribution of this work is the application of Modified
BPSO combined with a local search algorithm for solving task
assignment in heterogeneous multiprocessor platform. The task
assignment problem for a heterogeneous multiprocessor is solved
using modified particle swarm optimization and Novel Binary Particle Swarm Optimization algorithm and it is compared with Ant
Colony Optimization algorithm. This was done to find the best suitable algorithm for this application. The results show that modified
particle swarm optimization assigns more number of tasks for
problem instances with consistent utilization matrix, when compared to ACO. But Modified BPSO gives slightly lower performance
for inconsistent utilization matrix compared to ACO. This is because BPSO has weak local search ability. The Modified BPSO performance is higher compared to Novel BPSO for both consistent
and inconsistent utilization matrix. This is because; the position
update of the Modified BPSO uses the information of the current
position and the velocity. Energy optimization is done for feasible
solutions found by all the algorithms. In the case of objective function maximization (i.e. energy minimization) MBPSO performs better for most of the problem instances. But MBPSO takes more time
to solve the problem instance. Since the problem considered is offline scheduling the increase in execution time can be tolerated. The
execution time of the algorithms on nine different problem instances are simulated using MATLAB 7.6.0 (R2008a). The average
execution time taken for Modified BPSO is more compared to Novel
BPSO and ACO because the number of iterations required to get the
optimum result is more compared to other algorithms.
References
[1] S. Baruah, Task partitioning upon heterogeneous multiprocessor platforms,
Real-Time and Embedded Technology and Applications (2004) 1–8.
[2] Marco Dorigo, Thomas Stützle, Ant Colony Optimization, MIT Press, 2004.
[3] T.D. Burd, R.W. Brodersen, Energy efficient CMOS microprocessor design, in:
Proc. Hawaii Int’l Conf. System Science, January 1995, pp. 288–297.
[4] D. Zhu, R. Melhem, B.R. Childers, Scheduling with dynamic voltage/speed
adjustment using slack reclamation in multiprocessor real-time systems, IEEE
Transactions on Parallel and Distributed Systems 14 (7) (2003) 686–700.
[5] Albert M.K. Cheng, Real-Time Systems: Scheduling, Analysis, and Verification,
John Wiley & Sons, 2002.
Please cite this article in press as: K. Prescilla, A. Immanuel Selvakumar, Modified Binary Particle Swarm optimization algorithm application to real-time
task assignment in heterogeneous multiprocessor, Microprocess. Microsyst. (2013), http://dx.doi.org/10.1016/j.micpro.2013.05.003
K. Prescilla, A. Immanuel Selvakumar / Microprocessors and Microsystems xxx (2013) xxx–xxx
[6] S. Baruah, Partitioning real-time tasks among heterogeneous multiprocessors,
in: ICPP, 2004, pp. 1–8.
[7] Jia Xu, David Lorge Parnas, On satisfying timing constraints in hard-real-time
systems, IEEE Transactions on Software Engineering 19 (1) (1993) 70–84.
[8] T. Braun, Howard Jay Siegel, Noah Beck, A comparison of eleven static
heuristics for mapping a class of independent tasks onto heterogeneous
distributed computing systems, Journal of Parallel and Distributed Computing
61 (56) (2001) 810–837.
[9] Hakan Aydin, Qi Yang, Energy-aware partitioning for multiprocessor real-time
systems, in: Proc. Intl. Parallel and Distributed Processing Symposium, 2003,
pp. 9.
[10] Mojtaba Ahmadieh Khanesar, Mohammad Teshnehlab, Mahdi Aliyari
Shoorehdeli, A Novel Binary Particle Swarm Optimization, in: Proceedings of
the 15th Mediterranean Conference on Control & Automation, July 27–29,
2007.
[11] Sangwook Lee, Sangmoon Soak, Sanghoun Oh, Witold Pedrycz, Moongu Jeon,
Modified binary particle swarm optimization, Progress in Natural Science 18
(2008) 1161–1166.
[12] Hua Chen, Albert Mo Kim Cheng, Ying-Wei Kuo, Assigning real-time tasks to
heterogeneous processors by applying ant colony optimization, Journal of
Parallel Distributed Computing 71 (2011) 132–142.
[13] J. Kennedy, R.C. Eberhart, A discrete binary version of the particle swarm
algorithm, in: IEEE International Conference on Systems, Man, and
Cybernetics, 1997.
7
K. Prescilla received the bachelor’s degree in Electrical
and Electronics Engineering from Coimbatore Institute
of Technology, India, in 2004. M.E. in Applied Electronics
from Karunya University, India in 2006. She is currently
pursuing her Ph.D. in real time systems under the
supervision of Prof. Dr. A. Immanuel Selvakumar of
Karunya University. Her research interest is scheduling
in real-time systems. She has four years of teaching and
research experience and she was a member of IEEE.
A. Immanuel Selvakumar received the B.E. degree in
Electrical and Electronics Engineering and M.E. degree
in Power system Engineering from Thiagarajar College
of Engineering, Madurai, India. He received Ph.D. degree
in Electrical and Electronics engineering from Anna
University, Chennai, India. His research topics include
power system operation and control, soft computing
techniques and meta-heuristic optimization techniques.
He is a member of IEEE. He has presented eight papers
in referred International Journals.
Please cite this article in press as: K. Prescilla, A. Immanuel Selvakumar, Modified Binary Particle Swarm optimization algorithm application to real-time
task assignment in heterogeneous multiprocessor, Microprocess. Microsyst. (2013), http://dx.doi.org/10.1016/j.micpro.2013.05.003