A Fault Tolerant Adaptive Method for the Scheduling of Tasks in Dynamic Grids
ABSTRACT An essential issue in distributed highperformance computing is how to allocate efficiently the workload among the processors. This is specially important in a computational Grid where its resources are heterogeneous and dynamic. Algorithms like Quadratic SelfScheduling (QSS) and Exponential SelfScheduling (ESS) are useful to obtain a good load balance, reducing the communication overhead. Here, it is proposed a fault tolerant adaptive approach to schedule tasks in dynamic Grid environments. The aim of this approach is to optimize the list of chunks that QSS and ESS generates, that is, the way to schedule the tasks. For that, when the environment changes, new optimal QSS and ESS parameters are obtained to schedule the remaining tasks in an optimal way, maintaining a good load balance. Moreover, failed tasks are rescheduled. The results show that the adaptive approach obtains a good performance of both QSS and ESS even in a highly dynamic environment.
 Citations (25)
 Cited In (0)

Conference Paper: Dynamic matching and scheduling of a class of independent tasksonto heterogeneous computing systems
[Show abstract] [Hide abstract]
ABSTRACT: Dynamic mapping (matching and scheduling) heuristics for a class of independent tasks using heterogeneous distributed computing systems are studied. Two types of mapping heuristics are considered: online and batch mode heuristics. Three new heuristics, one for batch and two for online, are introduced as part of this research. Simulation studies are performed to compare these heuristics with some existing ones. In total, five online heuristics and three batch heuristics are examined. The online heuristics consider; to varying degrees and in different ways, task affinity for different machines and machine ready times. The batch heuristics consider these factors, as well as aging of tasks waiting to execute. The simulation results reveal that the choice of mapping heuristic depends on parameters such as: (a) the structure of the heterogeneity among tasks and machines, (b) the optimization requirements, and (c) the arrival rate of the tasksHeterogeneous Computing Workshop, 1999. (HCW '99) Proceedings. Eighth; 02/1999  SourceAvailable from: aaaipress.org[Show abstract] [Hide abstract]
ABSTRACT: David Goldberg's Genetic Algorithms in Search, Optimization and Machine Learning is by far the bestselling introduction to genetic algorithms. Goldberg is one of the preeminent researchers in the fieldhe has published over 100 research articles on genetic algorithms and is a student of John Holland, the father of genetic algorithmsand his deep understanding of the material shines through. The book contains a complete listing of a simple genetic algorithm in Pascal, which C programmers can easily understand. The book covers all of the important topics in the field, including crossover, mutation, classifier systems, and fitness scaling, giving a novice with a computer science background enough information to implement a genetic algorithm and describe genetic algorithms to a friend.AddisonWesley, Reading, Massachusetts. 01/1989;  SourceAvailable from: Walfredo CirneF. Berman, R. Wolski, H. Casanova, W. Cirne, H. Dail, M. Faerman, S. Figueira, J. Hayes, G. Obertelli, J. Schopf, G. Shao, S. Smallen, N. Spring, A. Su, D. Zagorodnov[Show abstract] [Hide abstract]
ABSTRACT: Ensembles of distributed, heterogeneous resources, also known as computational grids, have emerged as critical platforms for highperformance and resourceintensive applications. Such platforms provide the potential for applications to aggregate enormous bandwidth, computational power, memory, secondary storage, and other resources during a single execution. However, achieving this performance potential in dynamic, heterogeneous environments is challenging. Recent experience with distributed applications indicates that adaptivity is fundamental to achieving application performance in dynamic grid environments. The AppLeS (Application Level Scheduling) project provides a methodology, application software, and software environments for adaptively scheduling and deploying applications in heterogeneous, multiuser grid environments. We discuss the AppLeS project and outline our findings.IEEE Transactions on Parallel and Distributed Systems 05/2003; · 1.80 Impact Factor
Page 1
A Fault Tolerant Adaptive Method for the
Scheduling of Tasks in Dynamic Grids
Javier Díaz, Camelia MuñozCaro and Alfonso Niño
Grupo de Química Computacional y Computación de Alto Rendimiento,
Escuela Superior de Informática, Universidad de CastillaLa Mancha,
Paseo de la Universidad 4, 13071, Ciudad Real, Spain
Email:{javier.diaz, camelia.munoz, alfonso.nino}@uclm.es
Abstract— An essential issue in distributed highperformance
computing is how to allocate efficiently the workload among the
processors. This is specially important in a computational Grid
where its resources are heterogeneous and dynamic. Algorithms
like Quadratic SelfScheduling (QSS) and Exponential Self
Scheduling (ESS) are useful to obtain a good load balance,
reducing the communication overhead. Here, it is proposed a
fault tolerant adaptive approach to schedule tasks in dynamic
Grid environments. The aim of this approach is to optimize the
list of chunks that QSS and ESS generates, that is, the way
to schedule the tasks. For that, when the environment changes,
new optimal QSS and ESS parameters are obtained to schedule
the remaining tasks in an optimal way, maintaining a good load
balance. Moreover, failed tasks are rescheduled. The results show
that the adaptive approach obtains a good performance of both
QSS and ESS even in a highly dynamic environment.
Keywords  Adaptive Scheduling; Heuristic Scheduling; Self
Scheduling Algorithms; Computational Grid.
I. INTRODUCTION
Computational Grids [15] provide an opportunity to share
a large number of resources among different organizations
in an unified way, maximizing their use. A Grid can be
used effectively to support largescale runs of distributed
applications. An ideal case to be run in Grid is that with
many large independent tasks. This case arises naturally in
parameter sweep problems. A correct assignment of tasks,
so that computer loads and communication overheads are
well balanced, is the way to minimize the overall comput
ing time. This problem belongs to the active research topic
of the development and analysis of scheduling algorithms.
Different scheduling strategies have been developed along
the years (for the classical taxonomy, see [8]). In particular,
dynamic selfscheduling algorithms are extensively used in
practical applications [19] [22] [24]. These algorithms rep
resent adaptive schemes where tasks are allocated in runtime.
Selfscheduling algorithms were initially developed to solve
parallel loop scheduling problems in homogeneous shared
memory systems, see for instance [19]. This kind of algorithms
divides the set of tasks into subsets (chunks), and allocates
them among the processors (one chunk per processor). In this
way overheads are reduced.
Although selfscheduling algorithms were derived for ho
mogeneous systems, they could be applied to heterogeneous
ones such as Computational Grids [22] [24] [9] [10]. However,
the problem could be the flexibility of these algorithms (they
may have not enough degrees of freedom) to adapt efficiently
to a heterogeneous environment.
A Computational Grid is made up of a large number of
independent resource providers and consumers, which run
concurrently, change dynamically, and interact with each other.
Due to these environment characteristics, new approaches
such as those based on heuristic algorithms [25] [14] have
been proposed to address the challenges of Grid computing.
These kinds of algorithms make realistic assumptions based
on a priori knowledge of the concerning processes and of the
system load characteristics. Braun et al. [4] presented three
basic heuristics, based on Nature, for Grid scheduling. These
are: Genetic Algorithms (GA) [17], Simulated Annealing (SA)
[21] and Tabu Search (TS) [16].
Other way to tackle the problem of the unpredictable chang
ing conditions of the Grid is using Adaptive Grid scheduling
[18]. In general, adaptive scheduling can consider, among
others, factors such as availability, performance, workload,
bandwidth and latency of the interconnection links, etc, prop
erly scaled according to the application needs. In this sense,
there are several ways to provide adaptive Grid scheduling.
Thus, for instance, we can find frameworks as AppLeS [3],
Nimrod/G [6], Cactus Worm [1] or GridWay [18]. Moreover,
there are algorithms like adaptive factoring [2], Sufferage [20]
or XSufferage [7].
We have previously proposed two new flexible self
scheduling algorithms called Quadratic SelfScheduling (QSS)
[9] and Exponential SelfScheduling (ESS) [10] [11]. The
first is based on a quadratic form for the chunks distribution
function. The second approach, ESS, is based on the slope of
the chunks distribution function. In this case, we consider that
the chunks distribution function decreases in an exponential
way. Moreover, in previous works [10] we compared our
approaches with other selfscheduling algorithms in an actual
Grid environment. Our approaches outperformed the previous
ones, since they obtained better load balance and more re
duction of the communication overhead. However, QSS and
ESS depend on three and two parameters respectively, which
determine their behavior. Therefore, it is necessary to select
the most appropriate (optimal) values of these parameters for a
given computational environment. In this way, we could obtain
a good load balance and minimize the overall computation
Page 2
time.
Previously, we presented a way to obtain optimal QSS and
ESS parameters using a heuristic approach [12]. To such an
end, we simulated the execution environment (a Computational
Grid in our case). Using the simulation, we could obtain the
computational time of each algorithm for a given value of
its parameters. Therefore, it was possible to apply a heuristic
algorithm to explore the behavior of the scheduling method
for different values of the parameters, minimizing the overall
computation time. The heuristic algorithm selected was Sim
ulated Annealing (SA). However, these parameters were the
“best” ones for the environment where they were obtained.
Therefore, if the environment characteristics change strongly,
we could have a lack of efficiency. Thus, in [13] we introduced
an early version of a new adaptive approach to schedule
tasks in dynamic Grid environments. Using this approach, new
optimal QSS and ESS parameters were obtained when the
environment change. In this way, it was possible to maintain
a good load balance. In [13], we only considered the variation
of the processor’s computing power to simulate a dynamic
environment. However, in a real case both processors and
clusters can appear or disappear.
In this paper, we present a fault tolerant adaptive approach
to schedule tasks in dynamic Grid environments. Thus, the
adaptive approach also tackles the case in which processors
and clusters appear or disappear. In addition, if a processor or
cluster disappears, their tasks are rescheduled. We have used
this approach to compare the performance of the QSS and ESS
algorithms.
In the next section, we present an overview of the QSS and
ESS selfscheduling algorithms, as well as the methodology
used for their optimization. Section 3 presents and interprets
the results found in the optimization process. Finally, in
Section 4 we present the main conclusions of this paper and
the perspectives for future work.
II. METHODOLOGY
In this work, the Quadratic SelfScheduling (QSS) and
Exponential SelfScheduling (QSS) algorithms are used as
basic scheduling strategies. QSS [9] [10] [11] is based on
a Taylor expansion of the chunks distribution function, C(t),
limited to the quadratic term. Therefore, QSS is given by
C(t) = a + bt + ct2
(1)
where t represents the tth chunk assigned to a processor. To
apply QSS we need the a, b and c coefficients of equation (1).
Thus, assuming that the quadratic form is a good approach to
C(t), we can select three reference points (C(t), t) and solve for
the resulting system of equations. Useful points are (C0,0),
(CN/2, N/2) and (CN,N), where N is the total number of
chunks. Solving for a, b and c, we obtain,
a = C0
b = (4CN/2− CN− 3C0)/N
c = (2C0+ 2CN− 4CN/2)/N2
(2)
where N is defined [9] by,
N = 6I/(4CN/2+ CN+ C0)
(3)
being I the total number of tasks. The CN/2value is given by,
CN/2=CN+ C0
δ
(4)
where δ is a parameter. Assuming C0and CN are fixed, the
CN/2value determines the slope of equation (1) at a given
point. Therefore, depending on δ, the slope of the quadratic
function for a t value is higher or smaller than that of the
linear case, which corresponds to δ=2. In the present work, the
values of the three parameters, C0, CNand δ are heuristically
optimized in the simulated execution environment.
On the other hand, we have Exponential SelfScheduling
(ESS) [10] [11]. ESS belongs to the family of algorithms
based on the slope of the chunks distribution function, C(t).
So, we consider that the rate of variation of C(t) is a decreasing
function of t, g(t). Therefore, we have the general expression,
dC(t)/dt = g(t)
(5)
Equation (5) defines a differential equation. After integration
we will have an explicit functional form for C(t) as a function
of t.
ESS considers that the slope (negative) is proportional to
the chunk size. In this case g(t)=kC(t). Therefore,
dC(t)
dt
= −kC(t)
(6)
where k is a parameter and t represents the tth chunk assigned
to a processor. Equation (6) can be integrated by separation
of variables yielding [10],
C(t) = C0e−kt
(7)
Equation (7) defines the Exponential SelfScheduling (ESS)
algorithm. Here, C0and k are the parameters to be optimized
in the simulated working environment.
With respect to the SA heuristic approach [12], we consider
that the function to minimize, the cost function (f), is the
overall computation time needed to process all tasks, i.e., its
makespan. In turn, we consider that the cost function depends
on s, the set of parameters used by each selfscheduling
algorithm.
The cost function f(s) is obtained as the simulated time
(in arbitrary time units, atus) necessary to solve all tasks in
the specified execution environment. The tasks are scheduled
according to the chunk distribution of QSS or ESS. The chunk
distributions depend on the optimal QSS or ESS parameters,
which are given by the final value of s obtained by simulated
annealing. Moreover, in each cluster is allocated as many
chunks as processors available. The simulator is organized
as follows. Each task has associated a value, from 1 to 10,
which represents its duration (in atus). Task durations are
randomly generated. As previously commented, QSS and ESS
Page 3
allocate sets of tasks (chunks). Since all tasks are executed
in a single processor, the duration of a chunk is the sum
of all tasks durations composing it. The computing (CPU)
time for a chunk is calculated dividing its duration by the
relative computing power of the processor where the chunk
is executed. This computing power is referred to the fastest
processor. Thus, lower values correspond to slower processors.
To this value, we add the temporal cost of transferring the
chunk to the processor where it is executed. In addition, the
scheduling cost introduced by the local queueing software is
included as well. The resulting value represents the estimated
completion time.
The execution environment represented in the simulation
is an InternetBased Grid of computers [15]. Therefore, it
is composed by two main components: network links and
computer elements. Network links have associated a value
that represents the temporal cost, in atus, of transferring a file
between two machines through the Internet. On the other hand,
a computer element is typically a computer cluster [5]. This
is composed by a number of processors connected through an
internal network. So, each simulated computer element has an
associated array, which collects the relative computing power
(a real number) for its processors (CPUs). The temporal cost
of the internal network is considered negligible with respect
to the temporal cost of the Internet network links.
Using the previous heuristic approach, we can obtain the
“best” parameters for a given environment. However, if the
environment characteristics change strongly we could have a
lack of efficiency. Therefore, in [13] we presented an adaptive
approach to tackle this case. Nevertheless, in this work we
have improved this previous approach, to consider a more
realistic system in which processors or whole clusters can
appear or disappear. Thus, we have created an application,
which simulates the chunks execution (step by step) in an
environment as the one presented before. Moreover, if the
environment changes, it is updated in the simulator, generating
a new list of chunks to continue with the execution. The
previous heuristic will be used to generate a new list of chunks.
The corresponding pseudocode is shown in Chart 1.
Chart 1.Pseudocode for the Adaptive Approach
Function AdaptiveApproach()
1.Generate simulated execution environment
2.Obtain optimal parameters
3.Generate list of chunks
while there are chunks do
4.Start/Continue simulation of chunks
if environment changes then
5.Save current status
6.Update execution environment
if a processor or cluster disappear then
if all tasks were not executed then
7. Add all them to the pool of tasks
end_if
end_if
8.Look for new clusters or processors
9.Obtain new optimal parameters
10.Generate new list of chunks
end_if
done_while
end_Function
The first step generates the simulated execution environment.
After that, the optimal parameters of QSS or ESS algorithms
are obtained using the heuristic approach [12] described be
fore. With these parameters, we generate the list of chunks to
schedule the tasks. From here, the “while” loop represents the
new adaptive approach. In step 4, we simulate the execution
of chunks in the previous execution environment. If the
environment changes, the application will have to adapt itself.
Therefore, the current execution status is saved (step 5). This
information is a Gantt chart [23] for the estimated completion
time, in each processor, of the allocated chunks. Now, we
update the execution environment characteristics and restore
the saved execution status. In the case that a processor or a
cluster disappears, we check if its tasks were all executed. If
all tasks were not executed, we reschedule all of them (adding
them to the pool of tasks). After this, we look for new clusters
or processors. Since the environment has changed, we have
to generate new optimal parameters for our selfscheduling
algorithm. For that, we use the heuristic approach presented
in [12]. To obtain new parameters, we have to take into account
the saved execution status to consider only the nonallocated
tasks. This is important because each processor has a different
estimated completion time for its assigned chunks. In this way,
we obtain a better load balance. Once we have the new optimal
parameters for the selfscheduling algorithms, we generate a
new list of chunks and continue in the 4th step. The “while”
loop finishes when all tasks are scheduled and executed.
The simulated execution environment used is initially com
posed by three clusters (Hermes, Tales, Popo), see Tables
I and II. However, since the environment is dynamic, new
clusters can appear as well as disappear. In particular, we have
considered three additional clusters that can appear during
the execution, see Tables I and II. Moreover, in each cluster,
processors can appear or disappear. When a processor appears,
its computer power is selected randomly between 0.3 and
1. We have subdivided the environment characteristics into
three parts: network, processors and scheduling cost. After
several actual tests, we have observed that the queue managers
introduce the most important scheduling cost. In our case, this
cost is taking to be about 0.5 atus. In Tables I and II, we collect
the network and processors characteristics of each cluster.
TABLE I
NETWORK CHARACTERISTICS SPECIFIED USING ITS COST IN ARBITRARY
TEMPORAL UNITS (ATUS).
Computer Elements
Popo
4.612
Hermes
0.106
Tales
0.106
Edipo
1.612
Zenon
0.206
Aris
0.206
In this work, we perform several tests to verify the effect of
the adaptive approach in the efficiency of QSS and ESS upon
environment changes. Tests with 10000 tasks are considered.
During the tests we look for changes in the environment each
800 atus (checktime). This value is independent of the model
and it could be any other. Here, a processor has the possibility
Page 4
TABLE II
PROCESSORS CHARACTERISTICS FOR EACH COMPUTER ELEMENT. THE
NUMBER OF PROCESSORS OF EACH TYPE IS SPECIFIED USING ITS
RELATIVE COMPUTING POWER (R.P.).
Computer Elements
Tales Popo
11
R.P.
1
0.915
0.585
0.548
0.515
0.448
0.348
Hermes
5
Edipo
1
Zenon
1
Aris
2
1
34
1
3322
41
1
to increase, decrease or keep its performance in each check
time. We consider that the processor performance variation
rate is fixed to 10%. Previously, we studied the variation of
this percentage [13]. On the other hand, both clusters and
processors can appear or disappear during the execution in
each checktime. We consider different probabilities in each test
case. The probability that a processor appears or disappears
is taking as 10, 20 or 30 %. In the case of the clusters, the
probability is taking as 5, 10 or 15 %. In order to analyze the
behaviour of the adaptive approach, we perform tests in which
processors and clusters appear, disappear or both situations
together. Each test is performed 20 times to obtain average
results.
III. RESULTS
First, we have performed tests in which processors or
clusters only disappear. Thus, it is possible to observe the
influence of this situation in the behaviour of our algorithms.
The average results are collected in Figure 1. We observe that
in both cases, QSS and ESS, the performance is better when
the probability of processors or clusters disappearance is low.
In particular, clusters disappearance has the highest influence
on the performance, because it implies that several processors
disappear at one stroke. Moreover, we observe that ESS has
a better performance than QSS. In particular, the maximum
difference found is a 29%. The difference in the performance
is due to the way each algorithm distributes the tasks. ESS
generates a reduced list of chunks whose sizes are very large
at first, decreasing quickly. On the other hand, QSS generates
a longer list of chunks whose sizes are not so large at first
and decrease slowly. Thus, scheduling the tasks with ESS,
we could lose more tasks than using QSS, due to the size of
its chunks. However, this way to schedule the tasks provides
a better performance when there is a reduced number of
processors, because it reduces the network overheads keeping
the load balance. However, since QSS generates more chunks,
there are more probabilities that a chunk fails.
On the other hand, we have performed tests in which
processors or clusters only appear, see Figure 2. In this
case, the behaviour of both algorithms is the opposite of the
previous case. Here, the best situation is for a high probability
of processors or clusters appearance, because we get more
Fig. 1. Average ESS (up) and QSS (down) cost as a function of the processors
and clusters disappearance probability. The temporal cost is given in atus.
processors where execute the tasks. Moreover, we observe
that the QSS algorithm is up to a 12% better than ESS.
This is because the previous disadvantage of QSS now is an
advantage, since the higher number of chunks allows a better
load balance of the workload when new processors appear.
Fig. 2. Average ESS (up) and QSS (down) cost as a function of the processors
and clusters appearance probability. The temporal cost is given in atus.
Finally, we have tested the behaviour of QSS and ESS
Page 5
when processors or clusters appear and disappear. Here, the
probability of appearance or disappearance is the same. In
each checktime, we check if a processor or cluster disappears
and then if a processor or cluster appears. Figure 3 shows
graphically the behaviour of QSS and ESS. We observe that
the best behaviour of both algorithms is in the middle of
each figure. That is the expected behaviour, since this case
can be considered as the combination of the two previous
ones. Here, ESS provides better performance than QSS. The
maximum difference found is a 18%, although in some cases
both algorithms have very similar performance.
Fig. 3. Average ESS (up) and QSS (down) cost as a function of the processors
and clusters appearance/disappearance probability. The temporal cost is given
in atus.
These results show that the adaptive approach not only sup
ports fault tolerance, but also allows adaptability to changing
Grid environments. Thus, the execution time of this approach
when only the computer power of the processors changes
(semistatic environment) is 4242 and 4258 atus for the QSS
and ESS algorithms, respectively. Comparing these results
with those obtained when processors or clusters appear and
disappear, we find that in this last case the execution time
has a maximum delay of 27% and 15% for QSS and ESS
respectively. This difference is found for the case of 10%
processors probability and 15% clusters probability.
IV. CONCLUSION
In this work, we present a fault tolerant adaptive approach
to schedule tasks in dynamic Grid environments. Here, we
consider environments in which the computational power of
a processor can change, new processors or clusters can be
discovered, and processors or clusters can disappear. In the last
case, the failed tasks are rescheduled. We have seen that in a
dynamic environment where processors appear and disappear,
the behaviour of QSS and ESS is different, due to the way the
tasks are distributed into the chunks to be scheduled. Thus,
we observe that ESS has better performance when the number
of processors is reduced. On the other hand, QSS is better
when the number of processors increases. In the case where
processors and clusters appear and disappear, ESS is also
better than QSS. Therefore, the adaptive approach obtains a
good performance of the algorithms even in a highly dynamic
environment. In this situation, we find a maximum delay,
respect to the semistatic environment, of a 27% and 15%
for QSS and ESS, respectively.
In future works, our aim is to apply this approach to
schedule tasks in an actual Grid environment. In this way, we
can test if the adaptive approach is useful in an actual case.
ACKNOWLEDGMENT
This work has been cofinanced by FEDER funds, the Con
sejería de Educación y Ciencia de la Junta de Comunidades de
CastillaLa Mancha (grant # PBI080008), and the fellowship
associated to the grant # PBI05009. The Universidad de
CastillaLa Mancha is also acknowledged.
REFERENCES
[1] G. Allen, D. Angulo, I. Foster, G. Lanfermann, C. Liu, T. Radke, J.
Shalf,“The Cactus Worm: Experiments with dynamic resource discovery
and allocation in a grid environment,” Int. J. of High Performance
Computing Applications, vol. 15, no. 4, pp. 345358, 2001.
[2] I. Banicescu and V. Velusamy, “Load balancing highly irregular compu
tations with the adaptive factoring,” Proc. Int. Parallel and Distributed
Processing Symp., 2002, pp. 8798.
[3] F. Berman, R. Wolski, and H. Casanova, “Adaptive Computing on the
Grid Using AppLeS,” IEEE Trans. Parallel and Distributed Systems, vol.
14, no. 4, pp. 369382, 2003.
[4] R. Braun, H. Siegel, N. Beck, L. Boloni, M. Maheswaran, A. Reuther, J.
Robertson, M. Theys, B. Yao, D. Hensgen and R. Freund, “A Comparison
of Eleven Static Heuristics for Mapping a Class of Independent Tasks onto
Heterogeneous Distributed Computing Systems,” J. Par. Dist. Com., vol.
61, no. 6, pp. 810837, 2001.
[5] R. Buyya, High Performance Cluster Computing: Architectures and
Systems. New Jersey: Prentice Hall, vol. 1, 1999.
[6] R. Buyya, D. Abramson, and J. Giddy, “Nimrod/G: An Architecture of a
Resource Management and Scheduling System in a Global Computational
Grid,” 4th Int. Conf. on HighPerformance Computing in the AsiaPacific
Region, vol. 1, 2000, pp. 17.
[7] H. Casanova, D. Zagorodnov, F. Berman, A. Legrand, “Heuristics for
Scheduling Parameter Sweep Applications in Grid Environments,” Proc.
9th Heterogeneous Computing Workshop, 2000, pp. 349353.
[8] T. L. Casavant and J. G. Kuhl, “A Taxonomy of Scheduling in General
Purpose Distributed Computing,” IEEE Trans. Softw. Eng., vol. 14, no.
2, pp. 141154, 1988.
[9] J. Díaz, S. Reyes, A. Niño and C. MuñozCaro, “A Quadratic Self
Scheduling Algorithm for Heterogeneous Distributed Computing Sys
tems,” Proc. 5th Int. Workshop Algorithms, Models and Tools for Parallel
Computing Heterogeneous Networks (HeteroPar ’06), Barcelona, Spain,
2006, pp. 18.
[10] J. Díaz, S. Reyes, A. Niño, and C. MuñozCaro, “New SelfScheduling
Schemes for InternetBased Grids of Computers,” 1st Iberian Grid
Infrastructure Conf. (IBERGRID), Santiago de Compostela, Spain, 2007,
pp. 184195.
[11] J. Díaz, S. Reyes, A. Niño, C. MuñozCaro, “Derivation of Self
Scheduling Algorithms for Heterogeneous Distributed Computer Systems:
Application to Internetbased Grids of Computers,” Future Generation
Computer Systems, ElSevier, vol. 25, no. 6, pp. 617626, 2009.
Page 6
[12] J. Díaz, S. Reyes, C. MuñozCaro, and A. Niño, “A Heuristic Approach
to Task Scheduling in Internetbased Grids of Computers,” 2nd Int.
Conf. on Advanced Engineering Computing and Applications in Sciences
(ADVCOMP’08), Valencia, Spain, 2008, pp. 110116.
[13] J. Díaz, C. MuñozCaro, and A. Niño, “An Adaptive Approach to Task
Scheduling Optimization in Dynamic Grid Environments,” The 2009 Int.
Conf. on Grid Computing and Applications, Las Vegas, USA, 2009.
[14] F. Dong and S. G. Akl, “Scheduling algorithms for grid computing: State
of the art and open problems,” School of Computing, Queen’s University,
Kingston, Ontario, 2006.
[15] I. Foster and C. Kesselman, The Grid: Blueprint for a New Computing
Infrastructure, San Francisco, CA: Morgan Kauffman Publishers, 1999.
[16] F. Glover and M. Laguna, Tabu Search, Boston, MA: Kluwer Academic
Publishers, 1997.
[17] D. E. Goldberg, Genetic Algorithms in Search, Optimization, and
Machine Learning, Boston, MA: AddisonWesley, 1989.
[18] E. Huedo, R.S. Montero, I.M. Llorente, “Experiences on Adaptive Grid
Scheduling of Parameter Sweep Applications,” Proc. 12th Euromicro
Conference on Parallel,Distributed and NetworkBased Processing, 2004,
pp. 2833.
[19] D. J. Lilja, “Exploiting the Parallelism Available in Loops,” IEEE
Computer, vol. 27, vo. 2, pp. 1326, 1994.
[20] M. Maheswaran, S. Ali, H.J. Siegal, D. Hensgen, R.F. Freund, “Dynamic
Matching and Scheduling of a Class of Independent Tasks onto Het
erogeneous Computing Systems,” Proc. 8th Heterogeneous Computing
Workshop, 1999, pp. 3044.
[21] N. Metropolis, A. W. Rosenbluth, M. N. Rosenbluth, A. H. Teller, and
E. Teller, “Equations of State Calculations by Fast Computing Machines,”
J. Chem. Phys., vol. 21, pp. 10871091, 1953.
[22] S. Penmatsa, A. T. Chronopoulos, N. T. Karonis and B. Toonen, “Im
plementation of Distributed Loop Scheduling Schemes on the TeraGrid,”
Proc. 21st IEEE Int. Parallel and Distrib. Proc. Symp. (IPDPS 2007), 4th
High Performance Grid Computing Workshop, 2007.
[23] P.W.G. Morris, The Management of Projects, London : Thomas Telford,
1994.
[24] P. J. Sokolowski, D. Grosu and C. Xu, “Analysis of Performance
Behaviors of Grid Connected Clusters,” in Performance Evaluation of
Parallel and Distributed Systems, M. Ouldkhaoua, and G. Min, Eds.
Hauppauge, NY: Nova Science Publishers, 2006.
[25] J. Yu and R. Buyya, “Workflow Schdeduling Algorithms for Grid Com
puting,” Grid Computing and Distrib. Systems. Lab., Univ. Melbourne,
Australia, Tech. Rep., GRIDSTR200710, 2007.