Papers | Parallel Computing
2019
Maurizio Drocco, Paolo Viviani, Iacopo Colonnelli, Marco Aldinucci, Marco Grangetto
Accelerating spectral graph analysis through wavefronts of linear algebra operations Proceedings Article
In: Proc. of 27th Euromicro Intl. Conference on Parallel Distributed and network-based Processing (PDP), pp. 9–16, IEEE, Pavia, Italy, 2019.
Abstract | Links | BibTeX | Tags: grid
@inproceedings{19:gsp:pdp,
title = {Accelerating spectral graph analysis through wavefronts of linear algebra operations},
author = {Maurizio Drocco and Paolo Viviani and Iacopo Colonnelli and Marco Aldinucci and Marco Grangetto},
url = {https://iris.unito.it/retrieve/handle/2318/1695315/488105/19_wavefront_PDP.pdf},
doi = {10.1109/EMPDP.2019.8671640},
year = {2019},
date = {2019-01-01},
booktitle = {Proc. of 27th Euromicro Intl. Conference on Parallel Distributed and network-based Processing (PDP)},
pages = {9–16},
publisher = {IEEE},
address = {Pavia, Italy},
abstract = {The wavefront pattern captures the unfolding of a parallel computation in which data elements are laid out as a logical multidimensional grid and the dependency graph favours a diagonal sweep across the grid. In the emerging area of spectral graph analysis, the computing often consists in a wavefront running over a tiled matrix, involving expensive linear algebra kernels. While these applications might benefit from parallel heterogeneous platforms (multi-core with GPUs),programming wavefront applications directly with high-performance linear algebra libraries yields code that is complex to write and optimize for the specific application. We advocate a methodology based on two abstractions (linear algebra and parallel pattern-based run-time), that allows to develop portable, self-configuring, and easy-to-profile code on hybrid platforms.},
keywords = {grid},
pubstate = {published},
tppubtype = {inproceedings}
}
The wavefront pattern captures the unfolding of a parallel computation in which data elements are laid out as a logical multidimensional grid and the dependency graph favours a diagonal sweep across the grid. In the emerging area of spectral graph analysis, the computing often consists in a wavefront running over a tiled matrix, involving expensive linear algebra kernels. While these applications might benefit from parallel heterogeneous platforms (multi-core with GPUs),programming wavefront applications directly with high-performance linear algebra libraries yields code that is complex to write and optimize for the specific application. We advocate a methodology based on two abstractions (linear algebra and parallel pattern-based run-time), that allows to develop portable, self-configuring, and easy-to-profile code on hybrid platforms.
2012
Thomas Weigold, Marco Aldinucci, Marco Danelutto, Vladimir Getov
Process-Driven Biometric Identification by means of Autonomic Grid Components Journal Article
In: Int. J. of Autonomous and Adaptive Communications Systems, vol. 5, no. 3, pp. 274–291, 2012, ISSN: 1754-8632.
Abstract | Links | BibTeX | Tags: grid
@article{ibm:ijaacs:12,
title = {Process-Driven Biometric Identification by means of Autonomic Grid Components},
author = {Thomas Weigold and Marco Aldinucci and Marco Danelutto and Vladimir Getov},
url = {http://calvados.di.unipi.it/storage/paper_files/2012_JAACS_Weigold.pdf},
doi = {10.1504/IJAACS.2012.047659},
issn = {1754-8632},
year = {2012},
date = {2012-01-01},
journal = {Int. J. of Autonomous and Adaptive Communications Systems},
volume = {5},
number = {3},
pages = {274–291},
publisher = {Inderscience Enterprises Ltd.},
abstract = {Today's business applications are increasingly process driven, meaning that the main application logic is executed by a dedicate process engine. In addition, component-oriented software development has been attracting attention for building complex distributed applications. In this paper we present the experiences gained from building a process-driven biometric identification application that makes use of Grid infrastructures via the Grid Component Model (GCM). GCM, besides guaranteeing access to Grid resources, supports autonomic management of notable parallel composite components. This feature is exploited within our biometric identification application to ensure real time identification of fingerprints. Therefore, we briefly introduce the GCM framework and the process engine used, and we describe the implementation of the application by means of autonomic GCM components. Finally, we summarize the results, experiences, and lessons learned focusing on the integration of autonomic GCM components and the process-driven approach.},
keywords = {grid},
pubstate = {published},
tppubtype = {article}
}
Today's business applications are increasingly process driven, meaning that the main application logic is executed by a dedicate process engine. In addition, component-oriented software development has been attracting attention for building complex distributed applications. In this paper we present the experiences gained from building a process-driven biometric identification application that makes use of Grid infrastructures via the Grid Component Model (GCM). GCM, besides guaranteeing access to Grid resources, supports autonomic management of notable parallel composite components. This feature is exploited within our biometric identification application to ensure real time identification of fingerprints. Therefore, we briefly introduce the GCM framework and the process engine used, and we describe the implementation of the application by means of autonomic GCM components. Finally, we summarize the results, experiences, and lessons learned focusing on the integration of autonomic GCM components and the process-driven approach.
2011
Marco Aldinucci, Marco Danelutto, Peter Kilpatrick, Vamir Xhagjika
LIBERO: a framework for autonomic management of multiple non-functional concerns Proceedings Article
In: Guarracino, M. R., Vivien, F., Träff, J. L., Cannataro, M., Danelutto, M., Hast, A., Perla, F., Knüpfer, A., Martino, B. Di, Alexander, M. (Ed.): Euro-Par 2010 Workshops, Proc. of the CoreGrid Workshop on Grids, Clouds and P2P Computing, pp. 237–245, Springer, Ischia, Italy, 2011.
Abstract | Links | BibTeX | Tags: grid
@inproceedings{libero:cgsymph:10,
title = {LIBERO: a framework for autonomic management of multiple non-functional concerns},
author = {Marco Aldinucci and Marco Danelutto and Peter Kilpatrick and Vamir Xhagjika},
editor = {M. R. Guarracino and F. Vivien and J. L. Träff and M. Cannataro and M. Danelutto and A. Hast and F. Perla and A. Knüpfer and B. Di Martino and M. Alexander},
url = {http://calvados.di.unipi.it/storage/paper_files/2011_libero_coregridworkshop2010.pdf},
doi = {10.1007/978-3-642-21878-1_30},
year = {2011},
date = {2011-09-01},
booktitle = {Euro-Par 2010 Workshops, Proc. of the CoreGrid Workshop on Grids, Clouds and P2P Computing},
volume = {6586},
pages = {237–245},
publisher = {Springer},
address = {Ischia, Italy},
series = {LNCS},
abstract = {We describe a lightweight prototype framework (LIBERO) designed for experimentation with behavioural skeletons-components implementing a well-known parallelism exploitation pattern and a rule-based autonomic manager taking care of some non-functional feature related to pattern computation. LIBERO supports multiple autonomic managers within the same behavioural skeleton, each taking care of a different non-functional concern. We introduce LIBERO – built on plain Java and JBoss – and discuss how multiple managers may be coordinated to achieve a common goal using a two-phase coordination protocol developed in earlier work. We present experimental results that demonstrate how the prototype may be used to investigate autonomic management of multiple, independent concerns.},
keywords = {grid},
pubstate = {published},
tppubtype = {inproceedings}
}
We describe a lightweight prototype framework (LIBERO) designed for experimentation with behavioural skeletons-components implementing a well-known parallelism exploitation pattern and a rule-based autonomic manager taking care of some non-functional feature related to pattern computation. LIBERO supports multiple autonomic managers within the same behavioural skeleton, each taking care of a different non-functional concern. We introduce LIBERO – built on plain Java and JBoss – and discuss how multiple managers may be coordinated to achieve a common goal using a two-phase coordination protocol developed in earlier work. We present experimental results that demonstrate how the prototype may be used to investigate autonomic management of multiple, independent concerns.
2010
Marco Aldinucci, Marco Danelutto, Peter Kilpatrick
Autonomic Management of Multiple Non-Functional Concerns in Behavioural Skeletons Book Section
In: Desprez, Frédéric, Getov, Vladimir, Priol, Thierry, Yahyapour, Ramin (Ed.): Grids, P2P and Services Computing, pp. 89–103, Springer, 2010.
Abstract | Links | BibTeX | Tags: grid
@incollection{multiple-nf-concern:cgsymph:09:book,
title = {Autonomic Management of Multiple Non-Functional Concerns in Behavioural Skeletons},
author = {Marco Aldinucci and Marco Danelutto and Peter Kilpatrick},
editor = {Frédéric Desprez and Vladimir Getov and Thierry Priol and Ramin Yahyapour},
url = {http://calvados.di.unipi.it/storage/paper_files/2009_CGSymph_Autonomic_BeSke.pdf},
doi = {10.1007/978-1-4419-6794-7_8},
year = {2010},
date = {2010-08-01},
booktitle = {Grids, P2P and Services Computing},
pages = {89–103},
publisher = {Springer},
series = {CoreGRID},
abstract = {We introduce and address the problem of concurrent autonomic management of different non-functional concerns in parallel applications build as a hierarchical composition of behavioural skeletons. We first define the problems arising when multiple concerns are dealt with by independent managers, then we propose a methodology supporting coordinated management, and finally we discuss how autonomic management of multiple concerns may be implemented in a typical use case. Being based on the behavioural skeleton concept proposed in the CoreGRID GCM, it is anticipated that the methodology will be readily integrated into the current reference implementation of GCM based on Java ProActive and running on top of major grid middleware systems.},
keywords = {grid},
pubstate = {published},
tppubtype = {incollection}
}
We introduce and address the problem of concurrent autonomic management of different non-functional concerns in parallel applications build as a hierarchical composition of behavioural skeletons. We first define the problems arising when multiple concerns are dealt with by independent managers, then we propose a methodology supporting coordinated management, and finally we discuss how autonomic management of multiple concerns may be implemented in a typical use case. Being based on the behavioural skeleton concept proposed in the CoreGRID GCM, it is anticipated that the methodology will be readily integrated into the current reference implementation of GCM based on Java ProActive and running on top of major grid middleware systems.
Thomas Weigold, Marco Aldinucci, Marco Danelutto, Vladimir Getov
Integrating Autonomic Grid Components and Process-Driven Business Applications Proceedings Article
In: Vasilakos, Athanasios V., Beraldi, Roberto, Friedman, Roy, Mamei, Marco (Ed.): Autonomic Computing and Communications Systems Third International ICST Conference, Autonomics 2009, Limassol, Cyprus, September 9-11, 2009, Revised Selected Papers, pp. 98–113, Springer, Limassol, Cyprus, 2010, ISSN: 1867-8211.
Abstract | Links | BibTeX | Tags: grid
@inproceedings{ibm:autonomics:09,
title = {Integrating Autonomic Grid Components and Process-Driven Business Applications},
author = {Thomas Weigold and Marco Aldinucci and Marco Danelutto and Vladimir Getov},
editor = {Athanasios V. Vasilakos and Roberto Beraldi and Roy Friedman and Marco Mamei},
url = {http://calvados.di.unipi.it/storage/paper_files/2010_BS_autonomics09.pdf},
doi = {10.1007/978-3-642-11482-3_7},
issn = {1867-8211},
year = {2010},
date = {2010-01-01},
booktitle = {Autonomic Computing and Communications Systems Third International ICST Conference, Autonomics 2009, Limassol, Cyprus, September 9-11, 2009, Revised Selected Papers},
volume = {23},
pages = {98–113},
publisher = {Springer},
address = {Limassol, Cyprus},
series = {Lecture Notes of the Institute for Computer Sciences, Social-Informatics and Telecommunications Engineering (LNICST)},
abstract = {Today's business applications are increasingly process driven, meaning that the main application logic is executed by a dedicate process engine. In addition, component-oriented software development has been attracting attention for building complex distributed applications. In this paper we present the experiences gained from building a process-driven biometric identification application which makes use of Grid infrastructures via the Grid Component Model (GCM). GCM, besides guaranteeing access to Grid resources, supports autonomic management of notable parallel composite components. This feature is exploited within our biometric identification application to ensure real time identification of fingerprints. Therefore, we briefly introduce the GCM framework and the process engine used, and we describe the implementation of the application using autonomic GCM components. Finally, we summarize the results, experiences, and lessons learned focusing on the integration of autonomic GCM components and the process-driven approach.},
keywords = {grid},
pubstate = {published},
tppubtype = {inproceedings}
}
Today's business applications are increasingly process driven, meaning that the main application logic is executed by a dedicate process engine. In addition, component-oriented software development has been attracting attention for building complex distributed applications. In this paper we present the experiences gained from building a process-driven biometric identification application which makes use of Grid infrastructures via the Grid Component Model (GCM). GCM, besides guaranteeing access to Grid resources, supports autonomic management of notable parallel composite components. This feature is exploited within our biometric identification application to ensure real time identification of fingerprints. Therefore, we briefly introduce the GCM framework and the process engine used, and we describe the implementation of the application using autonomic GCM components. Finally, we summarize the results, experiences, and lessons learned focusing on the integration of autonomic GCM components and the process-driven approach.
2009
Marco Aldinucci, Hinde Lilia Bouziane, Marco Danelutto, Christian Pérez
STKM on SCA: a Unified Framework with Components, Workflows and Algorithmic Skeletons Proceedings Article
In: Proc. of 15th Intl. Euro-Par 2009 Parallel Processing, pp. 678–690, Springer, Delft, The Netherlands, 2009.
Abstract | Links | BibTeX | Tags: grid
@inproceedings{stkm:europar:09,
title = {STKM on SCA: a Unified Framework with Components, Workflows and Algorithmic Skeletons},
author = {Marco Aldinucci and Hinde Lilia Bouziane and Marco Danelutto and Christian Pérez},
url = {http://calvados.di.unipi.it/storage/paper_files/2009_STKM_Europar.pdf},
doi = {10.1007/978-3-642-03869-3},
year = {2009},
date = {2009-08-01},
booktitle = {Proc. of 15th Intl. Euro-Par 2009 Parallel Processing},
volume = {5704},
pages = {678–690},
publisher = {Springer},
address = {Delft, The Netherlands},
series = {LNCS},
abstract = {This paper investigates an implementation of STKM, a Spatio-Temporal sKeleton Model. STKM expands the Grid Component Model (GCM) with an innovative programmable approach that allows programmers to compose an application by combining component, workflow and skeleton concepts. The paper deals with a projection of the STKM model on top of SCA and it evaluates its implementation using Tuscany Java SCA. Experimental results show the need and the benefits of the high level of abstraction offered by STKM.},
keywords = {grid},
pubstate = {published},
tppubtype = {inproceedings}
}
This paper investigates an implementation of STKM, a Spatio-Temporal sKeleton Model. STKM expands the Grid Component Model (GCM) with an innovative programmable approach that allows programmers to compose an application by combining component, workflow and skeleton concepts. The paper deals with a projection of the STKM model on top of SCA and it evaluates its implementation using Tuscany Java SCA. Experimental results show the need and the benefits of the high level of abstraction offered by STKM.
2008
Marco Aldinucci, Marco Danelutto, Giorgio Zoppi, Peter Kilpatrick
Advances in Autonomic Components & Services Proceedings Article
In: Priol, Thierry, Vanneschi, Marco (Ed.): From Grids To Service and Pervasive Computing (Proc. of the CoreGRID Symposium 2008), pp. 3–18, Springer, Las Palmas, Spain, 2008, ISBN: 978-0-387-09454-0.
Abstract | Links | BibTeX | Tags: grid
@inproceedings{sca:cgsymph:08,
title = {Advances in Autonomic Components & Services},
author = {Marco Aldinucci and Marco Danelutto and Giorgio Zoppi and Peter Kilpatrick},
editor = {Thierry Priol and Marco Vanneschi},
url = {http://calvados.di.unipi.it/storage/paper_files/2008_SCA_cgsymph.pdf},
doi = {10.1007/978-0-387-09455-7_1},
isbn = {978-0-387-09454-0},
year = {2008},
date = {2008-08-01},
booktitle = {From Grids To Service and Pervasive Computing (Proc. of the CoreGRID Symposium 2008)},
pages = {3–18},
publisher = {Springer},
address = {Las Palmas, Spain},
series = {CoreGRID},
abstract = {Hierarchical autonomic management of structured grid applications can be efficiently implemented using production rule engines. Rules of the form "precondition-to-action" can be used to model the behaviour of autonomic managers in such a way that the autonomic control and the application management strategy are kept separate. This simplifies the manager design as well as user customization of autonomic manager policies. We briefly introduce rule-based autonomic managers. Then we discuss an implementation of a GCM-like behavioural skeleton – a composite component modelling a standard parallelism exploitation pattern with its own autonomic controller – in SCA/Tuscany. The implementation uses the JBoss rules engine to provide an autonomic behavioural skeleton component and services to expose the component functionality to the standard service framework. Performance results are discussed and finally similarities and differences with respect to the ProActive-based reference GCM implementation are discussed briefly.},
keywords = {grid},
pubstate = {published},
tppubtype = {inproceedings}
}
Hierarchical autonomic management of structured grid applications can be efficiently implemented using production rule engines. Rules of the form "precondition-to-action" can be used to model the behaviour of autonomic managers in such a way that the autonomic control and the application management strategy are kept separate. This simplifies the manager design as well as user customization of autonomic manager policies. We briefly introduce rule-based autonomic managers. Then we discuss an implementation of a GCM-like behavioural skeleton – a composite component modelling a standard parallelism exploitation pattern with its own autonomic controller – in SCA/Tuscany. The implementation uses the JBoss rules engine to provide an autonomic behavioural skeleton component and services to expose the component functionality to the standard service framework. Performance results are discussed and finally similarities and differences with respect to the ProActive-based reference GCM implementation are discussed briefly.
Marco Aldinucci, Emilio Tuosto
Towards a Formal Semantics for Autonomic Components Proceedings Article
In: Priol, Thierry, Vanneschi, Marco (Ed.): From Grids To Service and Pervasive Computing (Proc. of the CoreGRID Symposium 2008), pp. 31–45, Springer, Las Palmas, Spain, 2008, ISBN: 978-0-387-09454-0.
Abstract | Links | BibTeX | Tags: grid
@inproceedings{sem:cgsymph:08,
title = {Towards a Formal Semantics for Autonomic Components},
author = {Marco Aldinucci and Emilio Tuosto},
editor = {Thierry Priol and Marco Vanneschi},
url = {http://calvados.di.unipi.it/storage/paper_files/2008_sem_cgsymph.pdf},
doi = {10.1007/978-0-387-09455-7_3},
isbn = {978-0-387-09454-0},
year = {2008},
date = {2008-08-01},
booktitle = {From Grids To Service and Pervasive Computing (Proc. of the CoreGRID Symposium 2008)},
pages = {31–45},
publisher = {Springer},
address = {Las Palmas, Spain},
series = {CoreGRID},
abstract = {Autonomic management can improve the QoS provided by parallel/distributed applications. Within the CoreGRID Component Model, the autonomic management is tailored to the automatic – monitoring-driven – alteration of the component assembly and, therefore, is defined as the effect of (distributed)management code. This work yields a semantics based on hypergraph rewriting suitable tomodel the dynamic evolution and non-functional aspects of Service Oriented Architectures and component-based autonomic applications. In this regard, our main goal is to provide a formal description of adaptation operations that are typically only informally specified. We advocate that our approach makes easier to raise the level of abstraction of management code in autonomic and adaptive applications.},
keywords = {grid},
pubstate = {published},
tppubtype = {inproceedings}
}
Autonomic management can improve the QoS provided by parallel/distributed applications. Within the CoreGRID Component Model, the autonomic management is tailored to the automatic – monitoring-driven – alteration of the component assembly and, therefore, is defined as the effect of (distributed)management code. This work yields a semantics based on hypergraph rewriting suitable tomodel the dynamic evolution and non-functional aspects of Service Oriented Architectures and component-based autonomic applications. In this regard, our main goal is to provide a formal description of adaptation operations that are typically only informally specified. We advocate that our approach makes easier to raise the level of abstraction of management code in autonomic and adaptive applications.
Marco Aldinucci, Marco Danelutto, Peter Kilpatrick, Patrizio Dazzi
From Orc Models to Distributed Grid Java code Proceedings Article
In: Gorlatch, Sergei, Fragopoulou, Paraskevi, Priol, Thierry (Ed.): Proc. of the Integrated Research in Grid Computing Workshop, pp. 2–13, Hersonissos, Crete, Greece, 2008.
Abstract | Links | BibTeX | Tags: grid
@inproceedings{orc:IW:08,
title = {From Orc Models to Distributed Grid Java code},
author = {Marco Aldinucci and Marco Danelutto and Peter Kilpatrick and Patrizio Dazzi},
editor = {Sergei Gorlatch and Paraskevi Fragopoulou and Thierry Priol},
url = {http://calvados.di.unipi.it/storage/paper_files/2008_IW_O2J.pdf},
year = {2008},
date = {2008-04-01},
booktitle = {Proc. of the Integrated Research in Grid Computing Workshop},
pages = {2–13},
address = {Hersonissos, Crete, Greece},
series = {CoreGRID},
abstract = {We present O2J, a Java library that allows implementation of Orc programs on distributed architectures including grids and clusters/networks of workstations. With minimal programming effort the grid programmer may implement Orc programs, as he/she is not required to write any low level code relating to distributed orchestration of the computation but only that required to implement Orc expressions. Using the prototype O2J implementation, grid application developers can reason about abstract grid orchestration code described in Orc. Once the required orchestration has been determined and its properties analysed, a grid application prototype can be simply, efficiently and quickly implemented by taking the Orc code, rewriting it into corresponding Java/O2J syntax and finally providing the functional code implementing the sites and processes involved. The proposed modus operandi brings a Model Driven Engineering approach to grid application development.},
keywords = {grid},
pubstate = {published},
tppubtype = {inproceedings}
}
We present O2J, a Java library that allows implementation of Orc programs on distributed architectures including grids and clusters/networks of workstations. With minimal programming effort the grid programmer may implement Orc programs, as he/she is not required to write any low level code relating to distributed orchestration of the computation but only that required to implement Orc expressions. Using the prototype O2J implementation, grid application developers can reason about abstract grid orchestration code described in Orc. Once the required orchestration has been determined and its properties analysed, a grid application prototype can be simply, efficiently and quickly implemented by taking the Orc code, rewriting it into corresponding Java/O2J syntax and finally providing the functional code implementing the sites and processes involved. The proposed modus operandi brings a Model Driven Engineering approach to grid application development.
Marco Aldinucci, Sonia Campa, Marco Danelutto, Marco Vanneschi, Patrizio Dazzi, Domenico Laforenza, Nicola Tonellotto, Peter Kilpatrick
Behavioural skeletons in GCM: autonomic management of grid components Proceedings Article
In: Baz, Didier El, Bourgeois, Julien, Spies, Francois (Ed.): Proc. of Intl. Euromicro PDP 2008: Parallel Distributed and network-based Processing, pp. 54–63, IEEE, Toulouse, France, 2008.
Abstract | Links | BibTeX | Tags: grid
@inproceedings{orc:pdp:08,
title = {Behavioural skeletons in GCM: autonomic management of grid components},
author = {Marco Aldinucci and Sonia Campa and Marco Danelutto and Marco Vanneschi and Patrizio Dazzi and Domenico Laforenza and Nicola Tonellotto and Peter Kilpatrick},
editor = {Didier El Baz and Julien Bourgeois and Francois Spies},
url = {http://calvados.di.unipi.it/storage/paper_files/2008_orc_PDP.pdf},
doi = {10.1109/PDP.2008.46},
year = {2008},
date = {2008-02-01},
booktitle = {Proc. of Intl. Euromicro PDP 2008: Parallel Distributed and network-based Processing},
pages = {54–63},
publisher = {IEEE},
address = {Toulouse, France},
abstract = {Autonomic management can be used to improve the QoS provided by parallel/distributed applications. We discuss behavioural skeletons introduced in earlier work: rather than relying on programmer ability to design "from scratch" efficient autonomic policies, we encapsulate general autonomic controller features into algorithmic skeletons. Then we leave to the programmer the duty of specifying the parameters needed to specialise the skeletons to the needs of the particular application at hand. This results in the programmer having the ability to fast prototype and tune distributed/parallel applications with non-trivial autonomic management capabilities. We discuss how behavioural skeletons have been implemented in the framework of GCM (the grid component model developed within the CoreGRID NoE and currently being implemented within the GridCOMP STREP project). We present results evaluating the overhead introduced by autonomic management activities as well as the overall behaviour of the skeletons. We also present results achieved with a long running application subject to autonomic management and dynamically adapting to changing features of the target architecture. Overall the results demonstrate both the feasibility of implementing autonomic control via behavioural skeletons and the effectiveness of our sample behavioural skeletons in managing the "functional replication" pattern(s).},
keywords = {grid},
pubstate = {published},
tppubtype = {inproceedings}
}
Autonomic management can be used to improve the QoS provided by parallel/distributed applications. We discuss behavioural skeletons introduced in earlier work: rather than relying on programmer ability to design "from scratch" efficient autonomic policies, we encapsulate general autonomic controller features into algorithmic skeletons. Then we leave to the programmer the duty of specifying the parameters needed to specialise the skeletons to the needs of the particular application at hand. This results in the programmer having the ability to fast prototype and tune distributed/parallel applications with non-trivial autonomic management capabilities. We discuss how behavioural skeletons have been implemented in the framework of GCM (the grid component model developed within the CoreGRID NoE and currently being implemented within the GridCOMP STREP project). We present results evaluating the overhead introduced by autonomic management activities as well as the overall behaviour of the skeletons. We also present results achieved with a long running application subject to autonomic management and dynamically adapting to changing features of the target architecture. Overall the results demonstrate both the feasibility of implementing autonomic control via behavioural skeletons and the effectiveness of our sample behavioural skeletons in managing the "functional replication" pattern(s).
Marco Aldinucci, Marco Danelutto, Peter Kilpatrick
A framework for prototyping and reasoning about grid systems Proceedings Article
In: Bischof, C., Bücker, M., Gibbon, P., Joubert, G. R., Lippert, T., Mohr, B., Peters, F. J. (Ed.): Parallel Computing: Architectures, Algorithms and Applications, pp. 235–242, IOS press, Germany, 2008, ISBN: 9781586037963.
Abstract | Links | BibTeX | Tags: grid
@inproceedings{orc:parco:07,
title = {A framework for prototyping and reasoning about grid systems},
author = {Marco Aldinucci and Marco Danelutto and Peter Kilpatrick},
editor = {C. Bischof and M. Bücker and P. Gibbon and G. R. Joubert and T. Lippert and B. Mohr and F. J. Peters},
url = {http://calvados.di.unipi.it/storage/paper_files/2007_orc_parco.pdf},
isbn = {9781586037963},
year = {2008},
date = {2008-01-01},
booktitle = {Parallel Computing: Architectures, Algorithms and Applications},
volume = {15},
pages = {235–242},
publisher = {IOS press},
address = {Germany},
series = {ADVANCES IN PARALLEL COMPUTING},
abstract = {A framework supporting fast prototyping as well as tuning of distributed applications is presented. The approach is based on the adoption of a formal model that is used to describe the orchestration of distributed applications. The formal model (Orc by Misra and Cook) can be used to support semi-formal reasoning about the applications at hand. The paper describes how the framework can be used to derive and evaluate alternative orchestrations of a well know parallel/distributed computation pattern; and shows how the same formal model can be used to support generation of prototypes of distributed applications skeletons directly from the application description.},
keywords = {grid},
pubstate = {published},
tppubtype = {inproceedings}
}
A framework supporting fast prototyping as well as tuning of distributed applications is presented. The approach is based on the adoption of a formal model that is used to describe the orchestration of distributed applications. The formal model (Orc by Misra and Cook) can be used to support semi-formal reasoning about the applications at hand. The paper describes how the framework can be used to derive and evaluate alternative orchestrations of a well know parallel/distributed computation pattern; and shows how the same formal model can be used to support generation of prototypes of distributed applications skeletons directly from the application description.
2007
Marco Danelutto, Marcelo Pasin, Marco Vanneschi, Patrizio Dazzi, Luigi Presti, Domenico Laforenza
PAL: Exploiting Java Annotations for Parallelism Book Section
In: Bubak, Marian, Gorlatch, Sergei, Priol, Thierry (Ed.): Achievements in European Research on Grid Systems, pp. 83–96, Springer, Kraków, Poland, 2007.
@incollection{pal:IW_book:07,
title = {PAL: Exploiting Java Annotations for Parallelism},
author = {Marco Danelutto and Marcelo Pasin and Marco Vanneschi and Patrizio Dazzi and Luigi Presti and Domenico Laforenza},
editor = {Marian Bubak and Sergei Gorlatch and Thierry Priol},
year = {2007},
date = {2007-11-01},
booktitle = {Achievements in European Research on Grid Systems},
pages = {83–96},
publisher = {Springer},
address = {Kraków, Poland},
series = {CoreGRID},
keywords = {grid},
pubstate = {published},
tppubtype = {incollection}
}
Marco Aldinucci, Marco Danelutto, Peter Kilpatrick
Adding metadata to Orc to support reasoning about grid programming Proceedings Article
In: Priol, Thierry, Vanneschi, Marco (Ed.): Towards Next Generation Grids (Proc. of the CoreGRID Symposium 2007), pp. 205–214, Springer, Rennes, France, 2007, ISBN: 978-0-387-72497-3.
Abstract | Links | BibTeX | Tags: grid
@inproceedings{orc:metadata:cgs:07,
title = {Adding metadata to Orc to support reasoning about grid programming},
author = {Marco Aldinucci and Marco Danelutto and Peter Kilpatrick},
editor = {Thierry Priol and Marco Vanneschi},
url = {http://calvados.di.unipi.it/storage/paper_files/2007_orc_CGSymph.pdf},
doi = {10.1007/978-0-387-72498-0_19},
isbn = {978-0-387-72497-3},
year = {2007},
date = {2007-09-01},
booktitle = {Towards Next Generation Grids (Proc. of the CoreGRID Symposium 2007)},
pages = {205–214},
publisher = {Springer},
address = {Rennes, France},
series = {CoreGRID},
abstract = {Following earlier work demonstrating the utility of Orc as a means of specifying and reasoning about grid applications we propose the enhancement of such specifications with metadata that provide a means to extend an Orc specification with implementation oriented information. We argue that such specifications provide a useful refinement step in allowing reasoning about implementation related issues ahead of actual implementation or even prototyping. As examples, we demonstrate how such extended specifications can be used for investigating security related issues and for evaluating the cost of handling grid resource faults. The approach emphasises a semi-formal style of reasoning that makes maximum use of programmer domain knowledge and experience.},
keywords = {grid},
pubstate = {published},
tppubtype = {inproceedings}
}
Following earlier work demonstrating the utility of Orc as a means of specifying and reasoning about grid applications we propose the enhancement of such specifications with metadata that provide a means to extend an Orc specification with implementation oriented information. We argue that such specifications provide a useful refinement step in allowing reasoning about implementation related issues ahead of actual implementation or even prototyping. As examples, we demonstrate how such extended specifications can be used for investigating security related issues and for evaluating the cost of handling grid resource faults. The approach emphasises a semi-formal style of reasoning that makes maximum use of programmer domain knowledge and experience.
Marco Aldinucci, Marco Danelutto
The cost of security in skeletal systems Proceedings Article
In: D'Ambra, Pasqua, Guarracino, Mario Rosario (Ed.): Proc. of Intl. Euromicro PDP 2007: Parallel Distributed and network-based Processing, pp. 213–220, IEEE, Napoli, Italia, 2007.
Abstract | Links | BibTeX | Tags: grid
@inproceedings{security:euromicro:07,
title = {The cost of security in skeletal systems},
author = {Marco Aldinucci and Marco Danelutto},
editor = {Pasqua D'Ambra and Mario Rosario Guarracino},
url = {http://calvados.di.unipi.it/storage/paper_files/2007_security_PDP.pdf},
doi = {10.1109/PDP.2007.79},
year = {2007},
date = {2007-02-01},
booktitle = {Proc. of Intl. Euromicro PDP 2007: Parallel Distributed and network-based Processing},
pages = {213–220},
publisher = {IEEE},
address = {Napoli, Italia},
abstract = {Skeletal systems exploit algorithmical skeletons technology to provide the user very high level, efficient parallel programming environments. They have been recently demonstrated to be suitable for highly distributed architectures, such as workstation clusters, networks and grids. However, when using skeletal system for grid programming care must be taken to secure data and code transfers across non-dedicated, non-secure network links. In this work we take into account the cost of security introduction in muskel, a Java based skeletal system exploiting macro data flow implementation technology. We consider the adoption of mechanisms that allow securing all the communications taking place between remote, unreliable nodes and we evaluate the cost of such mechanisms. In particular, we consider the implications on the computational grains needed to scale secure and insecure skeletal computations.},
keywords = {grid},
pubstate = {published},
tppubtype = {inproceedings}
}
Skeletal systems exploit algorithmical skeletons technology to provide the user very high level, efficient parallel programming environments. They have been recently demonstrated to be suitable for highly distributed architectures, such as workstation clusters, networks and grids. However, when using skeletal system for grid programming care must be taken to secure data and code transfers across non-dedicated, non-secure network links. In this work we take into account the cost of security introduction in muskel, a Java based skeletal system exploiting macro data flow implementation technology. We consider the adoption of mechanisms that allow securing all the communications taking place between remote, unreliable nodes and we evaluate the cost of such mechanisms. In particular, we consider the implications on the computational grains needed to scale secure and insecure skeletal computations.
Marco Aldinucci, Sonia Campa, Massimo Coppola, Marco Danelutto, Corrado Zoccolo, Francoise André, Jérémy Buisson
An abstract schema modeling adaptivity management Book Section
In: Gorlatch, Sergei, Danelutto, Marco (Ed.): Integrated Research in Grid Computing, pp. 89–102, Springer, 2007, ISBN: 978-0-387-47656-8.
Abstract | Links | BibTeX | Tags: grid
@incollection{adapt_rennes:IW_book:06,
title = {An abstract schema modeling adaptivity management},
author = {Marco Aldinucci and Sonia Campa and Massimo Coppola and Marco Danelutto and Corrado Zoccolo and Francoise André and Jérémy Buisson},
editor = {Sergei Gorlatch and Marco Danelutto},
url = {http://calvados.di.unipi.it/storage/paper_files/2006_IW_book_adapt.pdf},
doi = {10.1007/978-0-387-47658-2_7},
isbn = {978-0-387-47656-8},
year = {2007},
date = {2007-01-01},
booktitle = {Integrated Research in Grid Computing},
pages = {89–102},
publisher = {Springer},
series = {CoreGRID},
abstract = {Nowadays, component application adaptivity in Grid environments has been afforded in different ways, such those provided by the Dynaco/AFPAC framework and by the ASSIST environment. We propose an abstract schema that catches all the designing aspects a model for parallel component applications on Grid should define in order to uniformly handle the dynamic behavior of computing resources within complex parallel applications. The abstraction is validated by demonstrating how two different approaches to adaptivity, ASSIST and Dynaco/AFPAC, easily map to such schema.},
keywords = {grid},
pubstate = {published},
tppubtype = {incollection}
}
Nowadays, component application adaptivity in Grid environments has been afforded in different ways, such those provided by the Dynaco/AFPAC framework and by the ASSIST environment. We propose an abstract schema that catches all the designing aspects a model for parallel component applications on Grid should define in order to uniformly handle the dynamic behavior of computing resources within complex parallel applications. The abstraction is validated by demonstrating how two different approaches to adaptivity, ASSIST and Dynaco/AFPAC, easily map to such schema.
Jan Dünnweber, Sergei Gorlatch, Sonia Campa, Marco Aldinucci, Marco Danelutto
Adaptable Parallel Components for Grid Programming Book Section
In: Gorlatch, Sergei, Danelutto, Marco (Ed.): Integrated Research in Grid Computing, pp. 43–57, Springer, 2007, ISBN: 978-0-387-47656-8.
Abstract | Links | BibTeX | Tags: grid
@incollection{codeadapt:IW_book:06,
title = {Adaptable Parallel Components for Grid Programming},
author = {Jan Dünnweber and Sergei Gorlatch and Sonia Campa and Marco Aldinucci and Marco Danelutto},
editor = {Sergei Gorlatch and Marco Danelutto},
url = {http://calvados.di.unipi.it/storage/paper_files/2006_IW_book_muester.pdf},
doi = {10.1007/978-0-387-47658-2_4},
isbn = {978-0-387-47656-8},
year = {2007},
date = {2007-01-01},
booktitle = {Integrated Research in Grid Computing},
pages = {43–57},
publisher = {Springer},
series = {CoreGRID},
abstract = {We suggest that parallel software components used for grid computing should be adaptable to application-specific requirements, instead of developing new components from scratch for each particular application. As an example, we take a parallel farm component which is "embarrassingly parallel", i. e. , free of dependencies, and adapt it to the wavefront processing pattern with dependencies that impact its behavior. We describe our approach in the context of Higher-Order Components (HOCs), with the Java-based system Lithium as our implementation framework. The adaptation process relies on HOCs' mobile code parameters that are shipped over the network of the grid. We describe our implementation of the proposed component adaptation method and report first experimental results for a particular grid application – the alignment of DNA sequence pairs, a popular, time-critical problem in computational molecular biology.},
keywords = {grid},
pubstate = {published},
tppubtype = {incollection}
}
We suggest that parallel software components used for grid computing should be adaptable to application-specific requirements, instead of developing new components from scratch for each particular application. As an example, we take a parallel farm component which is "embarrassingly parallel", i. e. , free of dependencies, and adapt it to the wavefront processing pattern with dependencies that impact its behavior. We describe our approach in the context of Higher-Order Components (HOCs), with the Java-based system Lithium as our implementation framework. The adaptation process relies on HOCs' mobile code parameters that are shipped over the network of the grid. We describe our implementation of the proposed component adaptation method and report first experimental results for a particular grid application – the alignment of DNA sequence pairs, a popular, time-critical problem in computational molecular biology.
2006
Marco Aldinucci, Marco Danelutto, Andrea Paternesi, Roberto Ravazzolo, Marco Vanneschi
Building interoperable grid-aware ASSIST applications via WebServices Proceedings Article
In: Joubert, G. R., Nagel, W. E., Peters, F. J., Plata, O., Tirado, P., Zapata, E. (Ed.): Parallel Computing: Current & Future Issues of High-End Computing (Proc. of PARCO 2005, Malaga, Spain), pp. 145–152, John von Neumann Institute for Computing, Germany, 2006, ISBN: 3000173528.
Abstract | Links | BibTeX | Tags: grid
@inproceedings{assist:webs:parco:05,
title = {Building interoperable grid-aware ASSIST applications via WebServices},
author = {Marco Aldinucci and Marco Danelutto and Andrea Paternesi and Roberto Ravazzolo and Marco Vanneschi},
editor = {G. R. Joubert and W. E. Nagel and F. J. Peters and O. Plata and P. Tirado and E. Zapata},
url = {http://calvados.di.unipi.it/storage/paper_files/2005_ws_parco.pdf},
isbn = {3000173528},
year = {2006},
date = {2006-12-01},
booktitle = {Parallel Computing: Current & Future Issues of High-End Computing (Proc. of PARCO 2005, Malaga, Spain)},
volume = {33},
pages = {145–152},
publisher = {John von Neumann Institute for Computing},
address = {Germany},
series = {NIC},
abstract = {The ASSIST environment provides a high-level programming toolkit for the grid. ASSIST applications are described by means of a coordination language, which can express arbitrary graphs of modules. These modules (or a graph of them) may be enclosed in components specifically designed for the grid (GRID.it components). In this paper we describe how ASSIST modules can be wired through standard Web Services, and how GRID.it components may be made available as standard Web Services.},
keywords = {grid},
pubstate = {published},
tppubtype = {inproceedings}
}
The ASSIST environment provides a high-level programming toolkit for the grid. ASSIST applications are described by means of a coordination language, which can express arbitrary graphs of modules. These modules (or a graph of them) may be enclosed in components specifically designed for the grid (GRID.it components). In this paper we describe how ASSIST modules can be wired through standard Web Services, and how GRID.it components may be made available as standard Web Services.
Marco Aldinucci, Gabriel Antoniu, Marco Danelutto, Mathieu Jan
Fault-Tolerant Data Sharing for High-level Grid Programming: A Hierarchical Storage Architecture Proceedings Article
In: Bubak, Marian, Gorlatch, Sergei, Priol, Thierry (Ed.): Proc. of the Integrated Research in Grid Computing Workshop, pp. 177–188, Academic Computing Centre CYFRONET AGH, Kraków, Poland, 2006.
Abstract | Links | BibTeX | Tags: grid
@inproceedings{assist:juxmem:IW:06,
title = {Fault-Tolerant Data Sharing for High-level Grid Programming: A Hierarchical Storage Architecture},
author = {Marco Aldinucci and Gabriel Antoniu and Marco Danelutto and Mathieu Jan},
editor = {Marian Bubak and Sergei Gorlatch and Thierry Priol},
url = {http://calvados.di.unipi.it/storage/paper_files/2006_IW_juxadhocmem.pdf},
year = {2006},
date = {2006-10-01},
booktitle = {Proc. of the Integrated Research in Grid Computing Workshop},
pages = {177–188},
publisher = {Academic Computing Centre CYFRONET AGH},
address = {Kraków, Poland},
series = {CoreGRID},
abstract = {Enabling high-level programming models on grids is today a major challenge. A way to achieve this goal relies on the use of environments able to transparently and automatically provide adequate support for low-level, grid-specific issues (fault-tolerance, scalability, etc.). This paper discusses the above approach when applied to grid data management. As a case study, we propose a 2-tier software architecture that supports transparent, fault-tolerant, grid-level data sharing in the ASSIST programming environment (University of Pisa), based on the JuxMem grid data sharing service (INRIA Rennes).},
keywords = {grid},
pubstate = {published},
tppubtype = {inproceedings}
}
Enabling high-level programming models on grids is today a major challenge. A way to achieve this goal relies on the use of environments able to transparently and automatically provide adequate support for low-level, grid-specific issues (fault-tolerance, scalability, etc.). This paper discusses the above approach when applied to grid data management. As a case study, we propose a 2-tier software architecture that supports transparent, fault-tolerant, grid-level data sharing in the ASSIST programming environment (University of Pisa), based on the JuxMem grid data sharing service (INRIA Rennes).
Marco Aldinucci, Carlo Bertolli, Sonia Campa, Massimo Coppola, Marco Vanneschi, Luca Veraldi, Corrado Zoccolo
Self-configuring and self-optimizing grid components in the GCM model and their ASSIST implementation Proceedings Article
In: Proc. of. HPC-GECO/Compframe (held in conjunction with HPDC-15), pp. 45–52, IEEE, Paris, France, 2006.
Abstract | Links | BibTeX | Tags: grid
@inproceedings{selfadapt:hpcgeco:06,
title = {Self-configuring and self-optimizing grid components in the GCM model and their ASSIST implementation},
author = {Marco Aldinucci and Carlo Bertolli and Sonia Campa and Massimo Coppola and Marco Vanneschi and Luca Veraldi and Corrado Zoccolo},
url = {http://calvados.di.unipi.it/storage/paper_files/2006_self_HPC-GECO.pdf},
year = {2006},
date = {2006-06-01},
booktitle = {Proc. of. HPC-GECO/Compframe (held in conjunction with HPDC-15)},
pages = {45–52},
publisher = {IEEE},
address = {Paris, France},
abstract = {We present the concept of autonomic super-component as a building block for Grid-aware applications. Super-components are parametric, higher-order components exhibiting a well-known parallel behaviour. The proposal of a super-component feature is part of the experience we gained in the implementation of the ASSIST environment, which allows the development of self-configuring and optimising component-based applications following a structured and hierarchical approach. We discuss how such approach to Grid programming influenced the design of the Grid Component Model (GCM).},
keywords = {grid},
pubstate = {published},
tppubtype = {inproceedings}
}
We present the concept of autonomic super-component as a building block for Grid-aware applications. Super-components are parametric, higher-order components exhibiting a well-known parallel behaviour. The proposal of a super-component feature is part of the experience we gained in the implementation of the ASSIST environment, which allows the development of self-configuring and optimising component-based applications following a structured and hierarchical approach. We discuss how such approach to Grid programming influenced the design of the Grid Component Model (GCM).
Marco Aldinucci, Marco Danelutto, Marco Vanneschi
Autonomic QoS in ASSIST Grid-aware components Proceedings Article
In: Proc. of Intl. Euromicro PDP 2006: Parallel Distributed and network-based Processing, pp. 221–230, IEEE, Montbéliard, France, 2006.
Abstract | Links | BibTeX | Tags: grid
@inproceedings{assist:qos:euromicro:06,
title = {Autonomic QoS in ASSIST Grid-aware components},
author = {Marco Aldinucci and Marco Danelutto and Marco Vanneschi},
url = {http://calvados.di.unipi.it/storage/paper_files/2006_QoS_PDP.pdf},
doi = {10.1109/PDP.2006.25},
year = {2006},
date = {2006-02-01},
booktitle = {Proc. of Intl. Euromicro PDP 2006: Parallel Distributed and network-based Processing},
pages = {221–230},
publisher = {IEEE},
address = {Montbéliard, France},
abstract = {Current Grid-aware applications are developed on existing software infrastructures, such as Globus, by developers who are experts on Grid software implementation. Although many useful applications have been produced this way, this approach may hardly support the additional complexity to Quality of Service (QoS) control in real application. We describe the ASSIST programming environment, the prototype of parallel programming environment currently under development at our group, as a suitable basis to capture all the desired features for QoS control for the Grid. Grid applications, built as compositions of ASSIST components, are supported by an innovative Grid Abstract Machine, which includes essential abstractions of standard middleware services and a hierarchical Application Manager, which may be considered as an early prototype of Autonomic Manager.},
keywords = {grid},
pubstate = {published},
tppubtype = {inproceedings}
}
Current Grid-aware applications are developed on existing software infrastructures, such as Globus, by developers who are experts on Grid software implementation. Although many useful applications have been produced this way, this approach may hardly support the additional complexity to Quality of Service (QoS) control in real application. We describe the ASSIST programming environment, the prototype of parallel programming environment currently under development at our group, as a suitable basis to capture all the desired features for QoS control for the Grid. Grid applications, built as compositions of ASSIST components, are supported by an innovative Grid Abstract Machine, which includes essential abstractions of standard middleware services and a hierarchical Application Manager, which may be considered as an early prototype of Autonomic Manager.
Marco Aldinucci, Massimo Coppola, Marco Danelutto, Marco Vanneschi, Corrado Zoccolo
ASSIST as a research framework for high-performance Grid programming environments Book Section
In: Cunha, J. C., Rana, O. F. (Ed.): Grid Computing: Software environments and Tools, pp. 230–256, Springer, 2006, ISBN: 978-1-85233-998-2.
Abstract | Links | BibTeX | Tags: grid
@incollection{assist:cunhabook:05,
title = {ASSIST as a research framework for high-performance Grid programming environments},
author = {Marco Aldinucci and Massimo Coppola and Marco Danelutto and Marco Vanneschi and Corrado Zoccolo},
editor = {J. C. Cunha and O. F. Rana},
url = {http://calvados.di.unipi.it/storage/paper_files/2005_assist_CuhnaBook.pdf},
doi = {10.1007/1-84628-339-6_10},
isbn = {978-1-85233-998-2},
year = {2006},
date = {2006-01-01},
booktitle = {Grid Computing: Software environments and Tools},
pages = {230–256},
publisher = {Springer},
chapter = {10},
abstract = {ASSIST is a programming environment supporting the development of parallel and distributed high-performance applications on a wide range of target architectures including massively parallel clusters/networks of workstations and Grids. We discuss how ASSIST can act as a valid research vehicle to study, experiment and realize Grid-aware programming environments for high-performance applications. Special emphasis is put on the innovative methodologies, strategies and tools for dynamically adaptive applications that represent the necessary step for the success of Grid platforms. We start considering which are the fundamental features of Grid-aware programming environments, based upon structured parallel programming and components technology. Then we show how ASSIST evolved from its very first version, only targeting workstation clusters, to the current version, targeting Grids and solving many critical problems related to expressive power, flexibility, interoperability and efficiency. We also discuss how ASSIST deals with interoperability issues. Eventually we discuss how an ASSIST-based model for supporting dynamically adaptive applications can be derived.},
keywords = {grid},
pubstate = {published},
tppubtype = {incollection}
}
ASSIST is a programming environment supporting the development of parallel and distributed high-performance applications on a wide range of target architectures including massively parallel clusters/networks of workstations and Grids. We discuss how ASSIST can act as a valid research vehicle to study, experiment and realize Grid-aware programming environments for high-performance applications. Special emphasis is put on the innovative methodologies, strategies and tools for dynamically adaptive applications that represent the necessary step for the success of Grid platforms. We start considering which are the fundamental features of Grid-aware programming environments, based upon structured parallel programming and components technology. Then we show how ASSIST evolved from its very first version, only targeting workstation clusters, to the current version, targeting Grids and solving many critical problems related to expressive power, flexibility, interoperability and efficiency. We also discuss how ASSIST deals with interoperability issues. Eventually we discuss how an ASSIST-based model for supporting dynamically adaptive applications can be derived.
Marco Aldinucci, Massimo Coppola, Sonia Campa, Marco Danelutto, Marco Vanneschi, Corrado Zoccolo
Structured implementation of component based grid programming environments Book Section
In: Getov, Vladimir, Laforenza, Domenico, Reinefeld, Alexander (Ed.): Future Generation Grids, pp. 217–239, Springer, 2006, ISBN: 978-0-387-27935-0.
Abstract | Links | BibTeX | Tags: grid
@incollection{assist:dagstuhl:05,
title = {Structured implementation of component based grid programming environments},
author = {Marco Aldinucci and Massimo Coppola and Sonia Campa and Marco Danelutto and Marco Vanneschi and Corrado Zoccolo},
editor = {Vladimir Getov and Domenico Laforenza and Alexander Reinefeld},
url = {http://calvados.di.unipi.it/storage/paper_files/2005_assist_Dagstuhl.pdf},
doi = {10.1007/978-0-387-29445-2_12},
isbn = {978-0-387-27935-0},
year = {2006},
date = {2006-01-01},
booktitle = {Future Generation Grids},
pages = {217–239},
publisher = {Springer},
series = {CoreGRID},
abstract = {The design,implementation and deployment of efficient high performance applications on Grids is usually a quite hard task, even in the case that modern and efficient grid middleware systems are used. We claim that most of the difficulties involved in such process can be moved away from programmer responsibility by following a structured programming model approach. The proposed approach relies on the development of a layered, component based execution environment. Each layer deals with distinct features and problems related to the implementation of GRID applications, exploiting the more appropriate techniques. Static optimizations are introduced in the compile layer, dynamic optimization are introduced in the run time layer, whereas modern grid middleware features are simply exploited using standard middleware systems as the final target architecture. We first discuss the general idea, then we discuss the peculiarities of the approach and eventually we discuss the preliminary results achieved in the GRID.it project, where a prototype high performance, component based, GRID programming environment is being developed using this approach.},
keywords = {grid},
pubstate = {published},
tppubtype = {incollection}
}
The design,implementation and deployment of efficient high performance applications on Grids is usually a quite hard task, even in the case that modern and efficient grid middleware systems are used. We claim that most of the difficulties involved in such process can be moved away from programmer responsibility by following a structured programming model approach. The proposed approach relies on the development of a layered, component based execution environment. Each layer deals with distinct features and problems related to the implementation of GRID applications, exploiting the more appropriate techniques. Static optimizations are introduced in the compile layer, dynamic optimization are introduced in the run time layer, whereas modern grid middleware features are simply exploited using standard middleware systems as the final target architecture. We first discuss the general idea, then we discuss the peculiarities of the approach and eventually we discuss the preliminary results achieved in the GRID.it project, where a prototype high performance, component based, GRID programming environment is being developed using this approach.
2005
Marco Aldinucci, Anne Benoit
Towards the Automatic Mapping of ASSIST Applications for the Grid Proceedings Article
In: Gorlatch, Sergei, Danelutto, Marco (Ed.): Proc. of the Integrated Research in Grid Computing Workshop, pp. 59–68, Università di Pisa, Dipartimento di Informatica, Pisa, Italy, 2005.
Abstract | Links | BibTeX | Tags: grid
@inproceedings{assist:pepa:IW:05,
title = {Towards the Automatic Mapping of ASSIST Applications for the Grid},
author = {Marco Aldinucci and Anne Benoit},
editor = {Sergei Gorlatch and Marco Danelutto},
url = {http://calvados.di.unipi.it/storage/paper_files/2006_IW_pepa.pdf},
year = {2005},
date = {2005-11-01},
booktitle = {Proc. of the Integrated Research in Grid Computing Workshop},
volume = {TR-05-22},
pages = {59–68},
publisher = {Università di Pisa, Dipartimento di Informatica},
address = {Pisa, Italy},
abstract = {One of the most promising technical innovations in present day computing is the invention of grid technologies which harness the computational power of widely distributed collections of computers. However, the programming and optimisation burden of a low level approach to grid computing is clearly unacceptable for large scale, complex applications. The development of grid applications can be simplified by using high-level programming environments. In the present work, we address the problem of the mapping of a high-level grid application onto the computational resources. In order to optimise the mapping of the application, we propose to automatically generate performance models from the application using the process algebra PEPA. We target in this work applications written with the high-level environment ASSIST, since the use of such a structured environment allows us to automate the study of the application more effectively.},
keywords = {grid},
pubstate = {published},
tppubtype = {inproceedings}
}
One of the most promising technical innovations in present day computing is the invention of grid technologies which harness the computational power of widely distributed collections of computers. However, the programming and optimisation burden of a low level approach to grid computing is clearly unacceptable for large scale, complex applications. The development of grid applications can be simplified by using high-level programming environments. In the present work, we address the problem of the mapping of a high-level grid application onto the computational resources. In order to optimise the mapping of the application, we propose to automatically generate performance models from the application using the process algebra PEPA. We target in this work applications written with the high-level environment ASSIST, since the use of such a structured environment allows us to automate the study of the application more effectively.
Jan Dünnweber, Sergei Gorlatch, Sonia Campa, Marco Aldinucci, Marco Danelutto
Using Code Parameters for Component Adaptations Proceedings Article
In: Gorlatch, Sergei, Danelutto, Marco (Ed.): Proc. of the Integrated Research in Grid Computing Workshop, pp. 49–57, Università di Pisa, Dipartimento di Informatica, Pisa, Italy, 2005.
Abstract | Links | BibTeX | Tags: grid
@inproceedings{codeadapt:IW:05,
title = {Using Code Parameters for Component Adaptations},
author = {Jan Dünnweber and Sergei Gorlatch and Sonia Campa and Marco Aldinucci and Marco Danelutto},
editor = {Sergei Gorlatch and Marco Danelutto},
url = {http://calvados.di.unipi.it/storage/paper_files/2006_IW_muenster.pdf},
year = {2005},
date = {2005-11-01},
booktitle = {Proc. of the Integrated Research in Grid Computing Workshop},
volume = {TR-05-22},
pages = {49–57},
publisher = {Università di Pisa, Dipartimento di Informatica},
address = {Pisa, Italy},
abstract = {Adaptation means that the behavior of a software component is adjusted to application or platform-specific requirements: new components required in a particular application do not need to be developed from scratch when available components can be adapted accordingly. Instead of introducing a new adaptation syntax (as it is done, e. g. , in AOP), we describe adaptations in the context of Java-based Higher-Order Components (HOCs). HOCs incorporate a code parameter plugin mechanism enabling adaptations on the grid. Our approach is illustrated using a case study of sequence alignment. We show how a HOC with the required provisions for data dependencies in this application can be generated by adapting a farm component, which is "embarrassingly parallel", i.e., free of data dependencies. This way, we could reuse the efficient farm implementation from the Lithium library, although our case study exhibits the wavefront pattern of parallelism which is different from the farm.},
keywords = {grid},
pubstate = {published},
tppubtype = {inproceedings}
}
Adaptation means that the behavior of a software component is adjusted to application or platform-specific requirements: new components required in a particular application do not need to be developed from scratch when available components can be adapted accordingly. Instead of introducing a new adaptation syntax (as it is done, e. g. , in AOP), we describe adaptations in the context of Java-based Higher-Order Components (HOCs). HOCs incorporate a code parameter plugin mechanism enabling adaptations on the grid. Our approach is illustrated using a case study of sequence alignment. We show how a HOC with the required provisions for data dependencies in this application can be generated by adapting a farm component, which is "embarrassingly parallel", i.e., free of data dependencies. This way, we could reuse the efficient farm implementation from the Lithium library, although our case study exhibits the wavefront pattern of parallelism which is different from the farm.
Marcelo Pasin, Pierre Kuonen, Marco Danelutto, Marco Aldinucci
Skeleton Parallel Programming and Parallel Objects Proceedings Article
In: Gorlatch, Sergei, Danelutto, Marco (Ed.): Proc. of the Integrated Research in Grid Computing Workshop, pp. 115–124, Università di Pisa, Dipartimento di Informatica, Pisa, Italy, 2005.
Abstract | Links | BibTeX | Tags: grid
@inproceedings{pasin:IW:05,
title = {Skeleton Parallel Programming and Parallel Objects},
author = {Marcelo Pasin and Pierre Kuonen and Marco Danelutto and Marco Aldinucci},
editor = {Sergei Gorlatch and Marco Danelutto},
url = {http://calvados.di.unipi.it/storage/paper_files/2006_IW_popc.pdf},
year = {2005},
date = {2005-11-01},
booktitle = {Proc. of the Integrated Research in Grid Computing Workshop},
volume = {TR-05-22},
pages = {115–124},
publisher = {Università di Pisa, Dipartimento di Informatica},
address = {Pisa, Italy},
abstract = {We describe here the ongoing work aimed at integrating the POP-C++ parallel object programming environment with the ASSIST component based parallel programming environment. Both these programming environments are shortly outlined, first. Then several possibilities of integration are considered. For each one of these integration opportunities, the advantages and synergies that can be possibly achieved are outlined and discussed. Eventually, the current status of integration of the two environments is discussed, along with the expected results and fallouts on the two programming environments.},
keywords = {grid},
pubstate = {published},
tppubtype = {inproceedings}
}
We describe here the ongoing work aimed at integrating the POP-C++ parallel object programming environment with the ASSIST component based parallel programming environment. Both these programming environments are shortly outlined, first. Then several possibilities of integration are considered. For each one of these integration opportunities, the advantages and synergies that can be possibly achieved are outlined and discussed. Eventually, the current status of integration of the two environments is discussed, along with the expected results and fallouts on the two programming environments.
Marco Aldinucci, Marco Vanneschi, Matteo Villa
Grid technologies and c-business for SMEs Proceedings Article
In: Cunningham, P., Cunningham, M. (Ed.): Innovation and the Knowledge Economy: Issues, Applications, Case Studies (Proc. of Intl. conference eChallenges 2005), IOS press, Amsterdam, The Netherland, 2005.
Abstract | Links | BibTeX | Tags: grid
@inproceedings{sfida:echallenges:05,
title = {Grid technologies and c-business for SMEs},
author = {Marco Aldinucci and Marco Vanneschi and Matteo Villa},
editor = {P. Cunningham and M. Cunningham},
url = {http://calvados.di.unipi.it/storage/paper_files/2005_SFIDA_echallenges.pdf},
year = {2005},
date = {2005-10-01},
booktitle = {Innovation and the Knowledge Economy: Issues, Applications, Case Studies (Proc. of Intl. conference eChallenges 2005)},
volume = {2},
publisher = {IOS press},
address = {Amsterdam, The Netherland},
series = {Information and Communication Technologies and the Knowledge Economy},
abstract = {We describe the objectives of project SFIDA, aiming at developing a Grid-based interoperable platform able to support next generation applications specifically addressing the needs of SMEs. We sketch the architecture of the platform under development in SFIDA, which will support componentization (e-services), intelligence (mining), collaboration (c-business), and customer business-processes orientation concepts on top of ASSIST, a Grid-aware high-level programming environment. The SFIDA project outcomes will be validated on Supply Chain Management applications matching various typical industrial cases, spanning from automotive, textile, food, white goods, and media retail. Finally we show what business benefits it is expected to bring.},
keywords = {grid},
pubstate = {published},
tppubtype = {inproceedings}
}
We describe the objectives of project SFIDA, aiming at developing a Grid-based interoperable platform able to support next generation applications specifically addressing the needs of SMEs. We sketch the architecture of the platform under development in SFIDA, which will support componentization (e-services), intelligence (mining), collaboration (c-business), and customer business-processes orientation concepts on top of ASSIST, a Grid-aware high-level programming environment. The SFIDA project outcomes will be validated on Supply Chain Management applications matching various typical industrial cases, spanning from automotive, textile, food, white goods, and media retail. Finally we show what business benefits it is expected to bring.
Marco Aldinucci, Alessandro Petrocelli, Edoardo Pistoletti, Massimo Torquati, Marco Vanneschi, Luca Veraldi, Corrado Zoccolo
Dynamic reconfiguration of grid-aware applications in ASSIST Proceedings Article
In: Cunha, J. C., Medeiros, P. D. (Ed.): Proc. of 11th Intl. Euro-Par 2005 Parallel Processing, pp. 771–781, Springer, 2005.
Abstract | Links | BibTeX | Tags: grid
@inproceedings{dyn:europar:05,
title = {Dynamic reconfiguration of grid-aware applications in ASSIST},
author = {Marco Aldinucci and Alessandro Petrocelli and Edoardo Pistoletti and Massimo Torquati and Marco Vanneschi and Luca Veraldi and Corrado Zoccolo},
editor = {J. C. Cunha and P. D. Medeiros},
url = {http://calvados.di.unipi.it/storage/paper_files/2005_assist_dyn_europar.pdf},
doi = {10.1007/11549468_84},
year = {2005},
date = {2005-08-01},
booktitle = {Proc. of 11th Intl. Euro-Par 2005 Parallel Processing},
volume = {3648},
pages = {771–781},
publisher = {Springer},
series = {LNCS},
abstract = {Current grid-aware applications are implemented on top of low-level libraries by developers who are experts on grid middleware architecture. This approach can hardly support the additional complexity of QoS control in real applications. We discuss a novel approach used in the ASSIST programming environment to implement/guarantee user provided QoS contracts in a transparent and effective way. Our approach is based on the implementation of automatic run-time reconfiguration of ASSIST application executions triggered by mismatch between the user provided QoS contract and the actual performance values achieved.},
keywords = {grid},
pubstate = {published},
tppubtype = {inproceedings}
}
Current grid-aware applications are implemented on top of low-level libraries by developers who are experts on grid middleware architecture. This approach can hardly support the additional complexity of QoS control in real applications. We discuss a novel approach used in the ASSIST programming environment to implement/guarantee user provided QoS contracts in a transparent and effective way. Our approach is based on the implementation of automatic run-time reconfiguration of ASSIST application executions triggered by mismatch between the user provided QoS contract and the actual performance values achieved.
Marco Aldinucci, Anne Benoit
Automatic mapping of ASSIST applications using process algebra Proceedings Article
In: Proc. of HLPP2005: Intl. Workshop on High-Level Parallel Programming, Warwick University, Coventry, UK 2005.
Abstract | Links | BibTeX | Tags: grid
@inproceedings{pepa_assist:hlpp:05,
title = {Automatic mapping of ASSIST applications using process algebra},
author = {Marco Aldinucci and Anne Benoit},
url = {http://calvados.di.unipi.it/storage/paper_files/2005_pepa_hlpp.pdf},
doi = {10.1142/S0129626408003302},
year = {2005},
date = {2005-07-01},
booktitle = {Proc. of HLPP2005: Intl. Workshop on High-Level Parallel Programming},
organization = {Warwick University, Coventry, UK},
abstract = {One of the most promising technical innovations in present-day computing is the invention of grid technologies which harness the computational power of widely distributed collections of computers. However, the programming and optimisation burden of a low level approach to grid computing is clearly unacceptable for large scale, complex applications. The development of grid applications can be simplified by using high-level programming environments. In the present work, we address the problem of the mapping of a high-level grid application onto the computational resources. In order to optimise the mapping of the application, we propose to automatically generate performance models from the application using the process algebra PEPA. We target applications written with the high-level environment ASSIST, since the use of such a structured environment allows us to automate the study of the application more effectively. Our methodology is presented through an example of a classical Divide&Conquer algorithm, together with results which demonstrate the efficiency of this approach.},
keywords = {grid},
pubstate = {published},
tppubtype = {inproceedings}
}
One of the most promising technical innovations in present-day computing is the invention of grid technologies which harness the computational power of widely distributed collections of computers. However, the programming and optimisation burden of a low level approach to grid computing is clearly unacceptable for large scale, complex applications. The development of grid applications can be simplified by using high-level programming environments. In the present work, we address the problem of the mapping of a high-level grid application onto the computational resources. In order to optimise the mapping of the application, we propose to automatically generate performance models from the application using the process algebra PEPA. We target applications written with the high-level environment ASSIST, since the use of such a structured environment allows us to automate the study of the application more effectively. Our methodology is presented through an example of a classical Divide&Conquer algorithm, together with results which demonstrate the efficiency of this approach.
Marco Aldinucci, Sergio Gusmeroli, Marco Vanneschi, Matteo Villa
SFIDA: interoperability in innovative c-business models for SMEs through an enabling Grid platform Proceedings Article
In: Pre-proc. of INTEROP-ESA: Intl. Conference on Interoperability on Enterprise Software and Applications, pp. 547–557, Geneva, Switzerland, 2005.
Abstract | Links | BibTeX | Tags: grid
@inproceedings{sfida:interop:05,
title = {SFIDA: interoperability in innovative c-business models for SMEs through an enabling Grid platform},
author = {Marco Aldinucci and Sergio Gusmeroli and Marco Vanneschi and Matteo Villa},
url = {http://calvados.di.unipi.it/storage/paper_files/2005_SFIDA_InteropESA.pdf},
year = {2005},
date = {2005-02-01},
booktitle = {Pre-proc. of INTEROP-ESA: Intl. Conference on Interoperability on Enterprise Software and Applications},
pages = {547–557},
address = {Geneva, Switzerland},
abstract = {This position paper describes the objectives of project "SFIDA" (co-funded by the Italian Government), aiming at developing a GRID-based inter-operability platform able to support next generation Supply Chain Management applications specifically addressing the needs of SMEs belonging to industrial districts and dynamic supply networks. Next generation SCM applications are intended in SFIDA to be based on componentization (e-services), intelligence (mining), collaboration (c-business) and customer business-processes orientation. The platform and the next generation SCM applications running on top of it will be tested in various typical industrial cases, spanning from automotive, textile, food, white goods and media retail.},
keywords = {grid},
pubstate = {published},
tppubtype = {inproceedings}
}
This position paper describes the objectives of project "SFIDA" (co-funded by the Italian Government), aiming at developing a GRID-based inter-operability platform able to support next generation Supply Chain Management applications specifically addressing the needs of SMEs belonging to industrial districts and dynamic supply networks. Next generation SCM applications are intended in SFIDA to be based on componentization (e-services), intelligence (mining), collaboration (c-business) and customer business-processes orientation. The platform and the next generation SCM applications running on top of it will be tested in various typical industrial cases, spanning from automotive, textile, food, white goods and media retail.
Marco Aldinucci, Sonia Campa, Massimo Coppola, Marco Danelutto, Domenico Laforenza, Diego Puppin, Luca Scarponi, Marco Vanneschi, Corrado Zoccolo
Components for high performance Grid programming in Grid.it Proceedings Article
In: Getov, V., Kielmann, T. (Ed.): Proc. of the Intl. Workshop on Component Models and Systems for Grid Applications, pp. 19–38, Springer, Saint-Malo, France, 2005, ISBN: 978-0-387-23351-2.
Abstract | Links | BibTeX | Tags: grid
@inproceedings{assist:stmalo:05,
title = {Components for high performance Grid programming in Grid.it},
author = {Marco Aldinucci and Sonia Campa and Massimo Coppola and Marco Danelutto and Domenico Laforenza and Diego Puppin and Luca Scarponi and Marco Vanneschi and Corrado Zoccolo},
editor = {V. Getov and T. Kielmann},
url = {http://calvados.di.unipi.it/storage/paper_files/2005_assist_ics_stmalo.pdf},
doi = {10.1007/0-387-23352-0_2},
isbn = {978-0-387-23351-2},
year = {2005},
date = {2005-01-01},
booktitle = {Proc. of the Intl. Workshop on Component Models and Systems for Grid Applications},
pages = {19–38},
publisher = {Springer},
address = {Saint-Malo, France},
series = {CoreGRID},
abstract = {This paper presents the main ideas of the high-performance component-based Grid programming environment of the Grid.it project. High-performance components are characterized by a programming model that integrates the concepts of structured parallelism, component interaction, compositionality, and adaptivity. We show that ASSIST, the prototype of parallel programming environment currently under development at our group, is a suitable basis to capture all the desired features of the component model in a flexible and efficient manner. For the sake of interoperability, ASSIST modules or programs are automatically encapsulated in standard frameworks; currently, we are experimenting Web Services and the CORBA Component Model. Grid applications, built as compositions of ASSIST components and possibly other existing (legacy) components, are supported by an innovative Grid Abstract Machine, that includes essential abstractions of standard middleware services and a hierarchical Application Manager (AM). AM supports static allocation and dynamic reallocation of adaptive applications according to a performance contract, a reconfiguration strategy, and a performance model.},
keywords = {grid},
pubstate = {published},
tppubtype = {inproceedings}
}
This paper presents the main ideas of the high-performance component-based Grid programming environment of the Grid.it project. High-performance components are characterized by a programming model that integrates the concepts of structured parallelism, component interaction, compositionality, and adaptivity. We show that ASSIST, the prototype of parallel programming environment currently under development at our group, is a suitable basis to capture all the desired features of the component model in a flexible and efficient manner. For the sake of interoperability, ASSIST modules or programs are automatically encapsulated in standard frameworks; currently, we are experimenting Web Services and the CORBA Component Model. Grid applications, built as compositions of ASSIST components and possibly other existing (legacy) components, are supported by an innovative Grid Abstract Machine, that includes essential abstractions of standard middleware services and a hierarchical Application Manager (AM). AM supports static allocation and dynamic reallocation of adaptive applications according to a performance contract, a reconfiguration strategy, and a performance model.