AGST - AUTONOMIC GRID SIMULATION TOOL

A Simulator of Autonomic Functions based on the MAPE-K Model

Berto de T´acio Pereira Gomes

and Francisco Jos´e da Silva e Silva

Electrical Engineering Graduate Program (PPGEE), Universidade Federal do Maranh˜ao (UFMA)

Av. dos Portugueses, s/n, Campus Universit´ario do Bacanga, CEP 65085-580, S˜ao Lu´ıs, MA, Brazil

Department of Computer Science (DEINF), Universidade Federal do Maranh˜ao (UFMA), S˜ao Lu´ıs, MA, Brazil

Keywords:

Computer grids, Discrete event simulator, Autonomic computing, MAPE-K cycle.

Abstract:

This paper describes AGST, a simulator tool for autonomic grids based on discrete events. The simulator pro-

vides, among others, tools for modeling grid resources and their network interconnections, grid applications

and their submissions, the occurrence of resource faults, resources local workload, and the use of workload

and fault traces following the SWF and FTA standards. AGST major contribution is the deﬁnition of a sim-

ulation model of the autonomic management cycle MAPE-K, which allows the simulation and evaluation of

autonomic grid middleware behavior, providing support for the monitoring, analysis, planning, and dynamic

execution of reconﬁguration actions to be applied to the simulated grid components.

1 INTRODUCTION

A computer grid is a system that coordinates dis-

tributed resources, using standard protocols and inter-

faces in order to allow the integration and sharing of

computing resources, such as computing power, soft-

ware, data, and peripherals in cooperate networks and

among institutions. The key component of a grid ar-

chitecture is its middleware, which is used to hide the

heterogeneous nature and the complexity generated

by the distribution of its resources. The middleware

provides to its users and applications an homogeneous

vision of the environment, through standardized inter-

faces for its several services.

The high scalability and heterogeneity of modern

computer grid environments and the dynamism of its

applications and infrastructure makes infeasible ap-

proaches based exclusively on the intervention of hu-

man agents to perform tasks such as conﬁguration,

maintenance, and recovery in case of failures. For

these reasons, it should be provided automated mech-

anisms that could facilitate the computer grid man-

agement. The term autonomic computing has been

used to denote computer systems capable of dynam-

ically adapting their behavior in response to varia-

tions in their execution environment according to es-

tablished policies and objectives, similar to the self-

regulatory behavior of biological systems.

Recent research efforts seek to apply autonomic

computing techniques to grid computing, providing

more autonomy and reducing the need for human

intervention in the maintenance and management of

these computing environments, thus creating the con-

cept an autonomic grid. Some of the investigated

subjects include the development of autonomic mech-

anisms for self-protection, such as detecting over-

loads that could potentially lead to disruption of ser-

vices; self-optimization, through parameter settings

and algorithms to detect performance degradations;

self-healing, to overcome possible partial system fail-

ures; and self-conﬁguration, by providing conﬁgured

virtual machines on demand and their dynamic al-

location to physical resources (Germain-Renaud and

Rana, 2009) (Jha et al., 2009) (Collet et al., 2010)

(Abraham et al., 2010).

During the development of a grid middleware, re-

searchers often use simulation tools to validate new

concepts and implementations. Simulation tools play

a key role in the development of grid middleware,

since: (a) researchers often do not have access to

large grid environments for testing, limiting the abil-

ity to evaluate situations that require a large amount

resources, (b) it is difﬁcult to explore large-scale ap-

plication scenarios that involvemultiple resources and

users in a repetitive and controlled way, due to the dy-

namic nature of grid environments, and (c) real-world

grid applications are usually time consuming and can

run for several weeks.

Over the last few years, several grid simulators

were developed, usually based on discrete events,

354

de Tácio Pereira Gomes B. and José da Silva e Silva F..

AGST - AUTONOMIC GRID SIMULATION TOOL - A Simulator of Autonomic Functions based on the MAPE-K Model.

DOI: 10.5220/0003601603540359

In Proceedings of 1st International Conference on Simulation and Modeling Methodologies, Technologies and Applications (SIMULTECH-2011), pages

354-359

ISBN: 978-989-8425-78-2

 2011 SCITEPRESS (Science and Technology Publications, Lda.)

such as: GridSim (Buyya and Murshed, 2002), Sim-

Grid (Howell and McNab, 1998), Alea (Klus´aˇcek

et al., 2008), GSSIM (Kurowski et al., 2007), DSiDE

(Chtepen et al., 2009), and OGST (Cunha Filho and

da Silva e Silva, 2008). None of them focused on

the development of a simulation model tailored to the

evaluation of autonomic grid features, such as moni-

toring the grid environment, analysis of context infor-

mation, reconﬁgurationplanning and the implementa-

tion of strategies that would allow the dynamic adap-

tation of the grid environment. Therefore, grid sim-

ulators do not have native support for the evaluation

of autonomic computing techniques to be applied on

computers grids.

The aim of this paper is to present AGST, an auto-

nomic grid simulator based on discrete events. AGST

major contribution is the deﬁnition of a simulation

model for evaluating autonomic grid behavior based

on the MAPE-K autonomic architecture (Kephart and

Chess, 2003), providing support for monitoring, anal-

ysis, planning, and dynamic execution of reconﬁgura-

tion actions to be applied to the simulated grid com-

ponents. This article is divided as follows: Section

2 provides a brief theoretical background on MAPE-

K autonomic architecture; Section 3 describes the

AGST simulator, its principles, motivations and grid

simulation model; Section 4 describes some related

work, while in Section 5 we draw our conclusions and

describe some future research directions.

2 MAPE-K ARCHITECTURE

The MAPE-K autonomic model, proposed by IBM

(Kephart and Chess, 2003) and illustrated in Figure

1, is a general architecture for the development of au-

tonomic software components. This model is being

increasingly used to interrelate the architectural com-

ponents of autonomic systems. It is divided into two

main software components: the autonomic manager

and the managed resource.

The managed resource corresponds to the system

or component providing the business logic that will

be dynamically adapted as the computing environ-

ment changes. The managed resource can be, for in-

stance, a Web server, a database, a software compo-

nent in a given application (e.g. the query optimizer

in a database), an operating system, etc. In an auto-

nomic grid, the task scheduler can be, for instance,

a managed resource. The autonomic manager per-

forms the functions comprising the adaptation logic

of the managed resource: monitoring, analysis, plan-

ning, and adaptation execution.

The MAPE-K model requires two types of touch-

Figure 1: MAPE-K: Autonomic Management Loop.

points within and outside the managed resource: sen-

sors and effectors. Only they have direct access to

the managed resource. Sensors are responsible for

collecting information from the managed resource,

which can be, for instance, the customers requests

response time, if the managed resource is a Web

server. The information collected by the sensors are

sent to the monitors where they are interpreted, pre-

processed and placed in a higher level of abstraction.

They are then sent to the next step of the cycle, the

analysis and planning phase. This stage produces an

action plan, which consists of a set of adaptation ac-

tions to be performed by the executor. The effectors

are the components that allow the autonomic man-

agers to perform adjustments in managed resources.

The decision of which adaptation actions must be ap-

plied in a given situation requires knowledge repre-

sentation of the computing system and its environ-

ment.

3 AGST

The AGST (Autonomic Grid Simulation Tool) main

goal is to easy the development of autonomic grid

middleware by providing a set of tools that allows the

evaluation of new autonomic concepts and their im-

plementations. In this way, the primary motivation for

the AGST developmentwas to providea tool that sup-

ports simulation and evaluation of autonomic comput-

ing techniques applied to computer grids. AGST ma-

jor innovationconsidering other well known grid sim-

ulators is the ability to simulate the functions deﬁned

in the MAPE-K autonomic management cycle, allow-

ing the simulation of autonomic grid mechanisms.

ASGT

was built based on OGST (Cunha Filho

www.lsd.ufma.br/˜agst

AGST - AUTONOMIC GRID SIMULATION TOOL - A Simulator of Autonomic Functions based on the MAPE-K Model

355

and da Silva e Silva, 2008), the GridSim (Buyya and

Murshed, 2002) toolkit and the SimJava framework

(Howell and McNab, 1998). SimJava is a discrete

event driven simulation framework that that mod-

els the system as a set of entities that communicate

among themselves through events. The (discrete)

simulation time steps increases based on the occur-

rence of these events. GridSim is a software platform

that allows users to model and simulate the charac-

teristics of grid resources and networks with different

settings. All tools were developed with the Java plat-

form.

3.1 Grid Simulation Model

The AGST allows an easy and ﬂexible modeling of

entities that comprise the grid computing environ-

ment, such as users, resources, applications, routers,

and so on. Typical grid environments events can also

be easily generated, such as the occurrence of re-

sources failures and their recovery events. The en-

tities that are part of the grid simulation model are

described in the following subsections.

3.1.1 Grid Resources and Network Links

GridSim provides the necessary entities for modeling

grid resources (

GridResource

), such as machinery

(

Machine

) and processors (

). AGST extensions to

GridSim allows the automatic generation of grid re-

sources through the use of probability distributions.

For this end, users must provide some parameters,

such as the number of nodes to be generated, the

probability distribution that best models the hetero-

geneity of the required resources, and the medium or

maximum and minimum processing power (deﬁned

in MIPS - Millions of Instructions Per Second), de-

pending on the probability distribution used.

The

GridResourcesGenerator

component is re-

sponsible for the grid resources generation, while

the

ResourceDataStorage

entity stores information

about the resources availability. The generated re-

sources can be of two types: dedicated (without hav-

ing local users applications running on background)

or non-dedicated (with a deﬁned workload simulating

the execution of local user applications).

The simulation model allows the automatic gener-

ation of a grid environment in which the resources are

spread across several administrative domains (sites).

The simulator user must provide parameters used for

deﬁning the sites interconnection network, such as

bandwidth, latency and the number of routers (entity

Router

3.1.2 Failures

Resources fault events (entity

FailureEvent

) and

their recovery (entity

RecoveryResource

) can be

synthetically generated or extracted from fault traces

databases collected from real environments using the

FTA (Failure Trace Archive) standard

(Kondo et al.,

2010). In the latter case, the user must provide

the database trace URL. The synthetic generation of

faults is based on probability distributions, such as ex-

ponential, Weibull and hyperexponential (Chwif and

Medina, 2007). The user must provide parameters ac-

cording to the distribution used. For example, when

using an exponential distribution, she/he must supply

the MTBF (Mean Time Between Failures) and MTTR

(Mean Time To Restore) values.

In AGST, applications execution recovery due to

node failures can be based on the restarting tech-

nique (tasks running on the failed node are re-

executed from start on other grid nodes) or on the

use of checkpoints. It is also possible to simulate

the applications execution using replication, another

technique commonly used in grid computing. The

ApplicationReplicationManager

entity is respon-

sible for managing the replicas execution.

3.1.3 Applications and Task Scheduling

Extensions to GridSim provided by AGST allow the

automatic generation of two types of applications:

regulars (consisting of a single task) and bag-of-

tasks (consisting of several independent tasks, run-

ning the same code in parallel using different input

data). GridSim does not embody an explicit applica-

tion model, providing only a basic entity representing

a task called

Gridlet

. Thus, on GridSim, applica-

tions generation is not automatic. The arrival time of

each application (entity

Application

) is set in sec-

onds, while their size is deﬁned in Million of Instruc-

tions.

In AGST, the automatic generation of applications

may occur in three ways: (1) synthetically, through

the use of probability distributions (uniform, Poisson,

exponential, hyperexponetial) to generate the tasks

size and the applications arrival time. The user must

choose the appropriate distributions considering the

desired simulation scenario; (2) from workload traces

following the GWF (Grid Workload Format)

and

SWF (Standard Workload Format)

standards; or (3),

through the Lublin model, a detailed model for appli-

http://fta.inria.fr/

http://gwa.ewi.tudelft.nl/pmwiki/

http://www.cs.huji.ac.il/labs/parallel/workload/swf.

html

SIMULTECH 2011 - 1st International Conference on Simulation and Modeling Methodologies, Technologies and

Applications

356

cations generation that was based on the analysis of

real grid environments traces.

The GridSim simulation model does not pro-

vide grid scheduling algorithms. AGST imple-

ments a library of widely used scheduling algo-

rithms in grids environments, such as: InteGrade,

Min-Min, MCT, and WQR (Gomes et al., 2010).

New strategies can also be easily added to the

available library.

GridScheduler (GS)

is the en-

tity responsible for mapping tasks to grid nodes

and running the scheduling algorithm (encapsulated

into a

SchedulingStrategy (SS)

entity). Each

GridResource

runs a

Resource Controller (RC)

entity, responsible for the instantiation and execution

of tasks scheduled to the node, keeping a list of tasks

waiting to be executed.

3.2 MAPE-K Simulation Model

In order to allow the simulation of autonomic grid

mechanisms, we developed in AGST a model in-

spired by the MAPE-K autonomic management cycle,

shown in Figure 1. The autonomic simulation model

contains the following entities:

Sensor

Monitor

Analyzer

Executor

, and

Effector

. These entities

are responsible for the autonomic management func-

tions of monitoring, analysis and planning, adaptation

control and execution. The autonomic entities com-

municate among themselves through events. Each en-

tity performs a well deﬁned function of the MAPE-K

loop, forming the autonomic manager. Any grid en-

tity can be implemented as a managed resource.

3.2.1 Monitoring

AGST monitoring entities aims to obtain data that re-

ﬂect changes in the behavior of the managed resource

or collect information from the simulated grid envi-

ronment that are relevant to the self-adaptation pro-

cess. For example, one may be interest in performing

some kind of adaptation if the CPU usage of a grid

node becomes less than 10%. During a simulation,

the monitoring function is performed by two entities

classes:

Sensor

and

Monitor

. The

Sensor

collects

data from the simulated grid environment and sends

them to the

Monitor

, responsible for data ﬁltering

before notifying the

Analyzer

entity of a given sit-

uation. The latter is responsible for the analysis and

planning functions.

The AGST was implemented in a way that the

simulated system knows about itself, its components

and interrelationships, their state and behavior (self-

awareness). In order to achieve this, AGST exten-

sively uses the resources deﬁned in the Java reﬂec-

tion API. Computational reﬂection refers to a soft-

ware ability to provide structures for its own repre-

sentation in a way that its behavior and the structures

that describes it are causally connected. This con-

nection determines the behavior of the system, that is

controlled through the manipulation of its representa-

tion. Sensors use computational reﬂection to acquire

knowledge concerning the structure of the managed

resource (variables, methods, constructors, interfaces,

relationships, hierarchy) and to get access to the vari-

ables that determine its state, even if their access are

deﬁned as protected and thus perform the sensing.

The knowledge necessary for analyzing the mon-

itored data and for deciding the set of adaptation ac-

tions that must be performed in a given situation is ex-

pressed by rules. Each rule is represented by a

Rule

entity. The

Monitor

notiﬁes the

Analyzer

of changes

on the monitored resource or the environment by gen-

erating a monitoring event (

MonitoringEvent

). Al-

though the simulation is oriented by discrete events,

the simulated monitoring function is time-oriented,

ie, the monitor is set with a simulated time interval

used for periodically collecting the environment data,

searching for the occurrence of signiﬁcant changes.

3.2.2 Analysis and Planning

The analysis phase occurs after the monitoring and

before planning. In the MAPE-K simulation model,

the two phases are represented together, since in

practice they are commonly implemented in a single

place. The analysis and planning process is essen-

tial to achieve grid autonomy, since they decide what

adaptations will be held in the managed resource. The

MAPE-K simulation model provides an entity called

Analyzer

to examine the data collected by the moni-

tors and to determine if changes should be made con-

cerning the current policies or strategies used in the

simulated grid environment. For example, if the CPU

use of a

GridResource

is greater than 70%, it can

be advantageous to migrate its tasks to a less busy

GridResource

, with the aim of minimizing the tasks

response time.

The

Analyser

receives the monitored data al-

ready ﬁltered out by the

Monitor

and then uses

knowledge-based rules to decide whether some kind

of adaptation must occur on the grid environment.

The analysis and planning phase produces a set of ac-

tions (implemented by the

Action

entity), called the

action plan (

ActionPlan

). These actions correspond

to the reconﬁguration operations that, according to the

decision-making mechanism, should be implemented

in the system in order to achievea given purpose (self-

optimization, self-healing, or self-protection). The

action plan is sent to the

Executor

, the entity respon-

sible for actually performing the changes in the simu-

AGST - AUTONOMIC GRID SIMULATION TOOL - A Simulator of Autonomic Functions based on the MAPE-K Model

357

lated system, by sending an

ActionPlanEvent

3.2.3 Control and Execution

The control and execution entities allow to simulate

the execution of reconﬁguration actions identiﬁed as

necessary by the analysis and planning functions. The

purpose of the reconﬁguration actions is to allow the

simulated grid system to evolve incrementally from

one conﬁguration to another at runtime, introduc-

ing little impact on the grid execution. In this way,

the grid components do not need to be ﬁnalized and

restarted in order to change them.

The self-conﬁguring feature allows the au-

tonomous system to automatically adjust to chang-

ing circumstances perceived on its own functioning

and its execution environment. The reconﬁguration

process in the MAPE-K simulation model is executed

by the

Executor

entities, using effectors (

Effector

As the sensors, effectors also use computational re-

ﬂection to acquire knowledge concerning the struc-

ture of the managed resource, as well as to get ac-

cess and alter the variables that determine its state.

The reconﬁguration execution is the ﬁnal stage of the

MAPE-K autonomic lifecycle management, taking as

input an

ActionPlan

generated by the analysis and

planning process.

The AGST MAPE-K simulation model allows the

execution of two adaptation approaches: parametric

and compositional. Parametric adaptation concerns

the modiﬁcation of variables that determine the sys-

tem behavior. For instance, one can adjust the amount

of task replicas generated by the a scheduling algo-

rithm. The parametric adaptation implements param-

eter variability, maintaining a current used strategy.

On the other hand, compositional adaptation concerns

the exchange of algorithms or structural parts of a

managed resource, allowing it to adopt a new strat-

egy in order to respond to a new environmental state.

Examples of compositional adaptation include the ad-

dition of a new behavior to the system, or replacing

parts of its components in order to circumvent even-

tual failures.

A component called

ExchangeComponent

is pro-

vided to support the effectors in the process of adapt-

ing a component through the use of computational re-

ﬂexion. This component is responsible for perform-

ing a component or attribute value substitution. The

ExchangeComponent

public methods have the syn-

chronized access modiﬁer to ensure that once a pro-

cess of replacing a component or attribute value is

started, it is not interrupted by another, and thus pre-

vent the concurrent execution of two or more adapta-

tion processes of a given component, preserving the

component state consistency.

4 RELATED WORK

There are several related work concerning the ﬁeld of

grid computing simulation. The majority of grid sim-

ulation tools are discrete event oriented and various

of them are based on the GridSim and SimJava sim-

ulators, such as Alea (Klus´aˇcek et al., 2008), GSSIM

(Kurowski et al., 2007), and OGST (Cunha Filho and

da Silva e Silva, 2008). Other examples of grid sim-

ulators found in the literature are SimGrid (Casanova

et al., 2008) and DSiDE (Chtepen et al., 2009).

GridSim is a simulation tool that allows the mod-

eling and simulation of parallel and distributed com-

puting systems entities. GSSIM and Alea are simu-

lators that extend GridSim providing functionalities

for the automatic generation of applications, com-

puting resources, and failures in a synthetic form or

through the use of trace ﬁles. SimGrid is a simula-

tor tool that provides the basic functionality for simu-

lating applications executions over an heterogeneous

distributed environment. DSiDE is a simulator that

was used in (Chtepen et al., 2009) to evaluate auto-

nomic approaches to fault tolerance concerning grid

applications execution. The aim of this work was to

investigatethe dynamic replacement of fault tolerance

strategies according to the grid executionenvironment

context.

Despite the great diversity of works related to grid

computing simulation, for the best of our knowledge

none of them address the problem of assisting the

middleware developer in the design and evaluation

of grid autonomic mechanisms by providing the sup-

port for the most used autonomic architecture: the

MAPE-K loop. This was the main motivation for the

AGST development, which has been used by our re-

search group at the Federal University of Maranh˜ao,

Brazil to evaluate autonomic self-optimizing and self-

healing strategies focused on grid environments.

5 CONCLUSIONS AND FUTURE

RESEARCH DIRECTIONS

Recent research efforts seek to apply autonomic com-

puting techniques to computer grids, providing more

autonomy and reducing the need for human inter-

vention in the maintenance and management of these

computing environments, thus creating the concept of

an autonomic grid. In spite of the fact that provi-

sioning a greater degree of autonomy to grid middle-

ware currently constitute one of the most active and

challenging research theme for grid computing, cur-

rent simulation tools lack an adequate support to as-

sist developers in designing and evaluating autonomic

SIMULTECH 2011 - 1st International Conference on Simulation and Modeling Methodologies, Technologies and

Applications

358

mechanisms for these environments.

In this work we described AGST, a new simulator

tool for assisting the development and evaluation of

autonomic grid mechanisms. The simulator provides,

among others, tools for modeling grid resources and

their network interconnections, grid applications and

their submissions, the occurrence of resource faults,

resources local workload, the use of workload and

fault traces following the SWF and FTA standards.

Nevertheless, AGST major contribution is the deﬁni-

tion and implementation of a simulation model based

on the MAPE-K autonomic architecture, that can be

used to simulate the monitoring, analysis and plan-

ning, control and execution functions, allowing the

simulation of an autonomic grid.

Our research group is currently using AGST to as-

sist the development and evaluation of self-optimizing

and self-healing strategies focused on grid computing

environments. The AGST simulations results were

consistent with the ones found on the autonomic grid

literature. In AGST evaluation meetings, middleware

developers reported a good effectiveness of the sim-

ulation tool in assisting the design and evaluation of

the autonomic mechanisms, highlighting the simplic-

ity of porting the developed code to a real environ-

ment, since all MAPE-K components are represented

in AGST.

As future work, we intend to perform experiments

in a real grid environment using the InteGrade mid-

dleware in order to compare the results with AGST

simulated ones. We are also investigating the use of

aspect oriented programming for simplifying cross-

cutting aspects of the AGST code.

ACKNOWLEDGEMENTS

This work is supported by the Brazilian Federal Re-

search Agency, CNPq, grant No.478853/2009-2.

REFERENCES

Abraham, L., Murphy, M. A., Fenn, M., and Goasguen, S.

(2010). Self-provisioned hybrid clouds. In Proceed-

ing of the 7th international conference on Autonomic

computing, ICAC’10, pages 161–168, New York, NY,

USA. ACM.

Buyya, R. and Murshed, M. (2002). Gridsim: A toolkit for

the modeling and simulation of distributed resource

management and scheduling for grid computing. Con-

currency and Computation: Practice and Experience,

14(13):1175–1220.

Casanova, H., Legrand, A., and Quinson, M. (2008). Sim-

grid: A generic framework for large-scale distributed

experiments. In Proceedings of the Tenth Interna-

tional Conference on Computer Modeling and Simu-

lation, pages 126–131, Washington, DC, USA. IEEE

Computer Society.

Chtepen, M., Claeys, F. H. A., Dhoedt, B., De Turck, F.,

Demeester, P., and Vanrolleghem, P. A. (2009). Adap-

tive task checkpointing and replication: Toward efﬁ-

cient fault-tolerant grids. IEEE Trans. Parallel Dis-

trib. Syst., 20:180–190.

Chwif, L. and Medina, A. C. (2007). Mode-

lagem e Simulac¸˜ao de Eventos Discretos. Teoria &

Aplicac¸˜oes. 2nd Ed. Author’s Edition, S˜ao Paulo,

Brazil. ISBN 8590597822.

Collet, P., Kˇrikava, F., Montagnat, J., Blay-Fornarino, M.,

and Manset, D. (2010). Issues and scenarios for self-

managing grid middleware. In Proceeding of the

2nd workshop on Grids meets autonomic computing,

GMAC ’10, pages 1–10, New York, NY, USA. ACM.

Cunha Filho, G. and da Silva e Silva, F. J. (2008). Ogst:

An opportunistic grid simulation tool. In LAGrid

2008: 2nd International Workshop Latin American

Grid, Campo Grande, Mato Grosso do Sul.

Germain-Renaud, C. and Rana, O. F. (2009). The conver-

gence of clouds , grids , and autonomics. IEEE Inter-

net Computing, 13(December):9–9.

Gomes, B. d. T. P., Cunha Filho, G., Campos, I. R.,

Goncalves, J. F., and da Silva e Silva, F. J. (2010).

Scheduling strategies evaluation for opportunistic

grids. Computing Systems, Symposium on, 0:88–95.

Howell, F. and McNab, R. (1998). simjava: A discrete event

simulation library for java. International Conference

on WebBased Modeling and Simulation, 30:51–56.

Jha, S., Parashar, M., and Rana, O. (2009). Investigat-

ing autonomic behaviours in grid-basedcomputational

science applications. In Proceedings of the 6th inter-

national conference industry session on Grids meets

autonomic computing, GMAC ’09, pages 29–38, New

York, NY, USA. ACM.

Kephart, J. O. and Chess, D. M. (2003). The vision of auto-

nomic computing. Computer, 36:41–50.

Klus´aˇcek, D., Matyska, L., and Rudov´a, H. (2008). Alea:

grid scheduling simulation environment. In Proceed-

ings of the 7th international conference on Paral-

lel processing and applied mathematics, PPAM’07,

pages 1029–1038, Berlin, Heidelberg. Springer-

Verlag.

Kondo, D., Javadi, B., Iosup, A., and Epema, D. (2010).

The failure trace archive: Enabling comparative anal-

ysis of failures in diverse distributed systems. In Pro-

ceedings of the 2010 10th IEEE/ACM International

Conference on Cluster, Cloud and Grid Computing,

CCGRID ’10, pages 398–407, Washington, DC, USA.

IEEE Computer Society.

Kurowski, K., Nabrzyski, J., Oleksiak, A., and Weglarz, J.

(2007). Grid scheduling simulations with gssim. In

Proceedings of the 13th International Conference on

Parallel and Distributed Systems - Volume 02, pages

1–8, Washington, DC, USA. IEEE Computer Society.

AGST - AUTONOMIC GRID SIMULATION TOOL - A Simulator of Autonomic Functions based on the MAPE-K Model

359