Papers | Parallel Computing
2021
Robert Birke, Juan F. Pérez, Zhan Qiu, Mathias Björkqvist, Lydia Y. Chen
sPARE: Partial Replication for Multi-Tier Applications in the Cloud Journal Article
In: IEEE Trans. Serv. Comput., vol. 14, no. 2, pp. 574–588, 2021.
Abstract | Links | BibTeX | Tags: parallel
@article{BirkePQBC21,
title = {sPARE: Partial Replication for Multi-Tier Applications in the Cloud},
author = {Robert Birke and Juan F. Pérez and Zhan Qiu and Mathias Björkqvist and Lydia Y. Chen},
url = {https://doi.org/10.1109/TSC.2017.2780845},
doi = {10.1109/TSC.2017.2780845},
year = {2021},
date = {2021-01-01},
journal = {IEEE Trans. Serv. Comput.},
volume = {14},
number = {2},
pages = {574–588},
abstract = {Offering consistent low latency remains a key challenge for distributed applications, especially when deployed on the cloud where virtual machines (VMs) suffer from capacity variability caused by co-located tenants. Replicating redundant requests was shown to be an effective mechanism to defend application performance from high capacity variability. While the prior art centers on single-tier systems, it still remains an open question how to design replication strategies for distributed multi-tier systems. In this paper, we design a first of its kind PArtial REplication system, sPARE, that replicates and dispatches read-only workloads for distributed multi-tier web applications. The two key components of sPARE are (i) the variability-aware replicator that coordinates the replication levels on all tiers via an iterative searching algorithm, and (ii) the replication-aware arbiter that uses a novel token-based arbitration algorithm (TAD) to dispatch requests in each tier. We evaluate sPARE on web serving and searching applications, i.e., MediaWiki and Solr, the former deployed on our private cloud and the latter on Amazon EC2. Our results based on various interference patterns and traffic loads show that sPARE is able to improve the tail latency of MediaWiki and Solr by a factor of almost 2.7x and 2.9x, respectively.},
keywords = {parallel},
pubstate = {published},
tppubtype = {article}
}
Offering consistent low latency remains a key challenge for distributed applications, especially when deployed on the cloud where virtual machines (VMs) suffer from capacity variability caused by co-located tenants. Replicating redundant requests was shown to be an effective mechanism to defend application performance from high capacity variability. While the prior art centers on single-tier systems, it still remains an open question how to design replication strategies for distributed multi-tier systems. In this paper, we design a first of its kind PArtial REplication system, sPARE, that replicates and dispatches read-only workloads for distributed multi-tier web applications. The two key components of sPARE are (i) the variability-aware replicator that coordinates the replication levels on all tiers via an iterative searching algorithm, and (ii) the replication-aware arbiter that uses a novel token-based arbitration algorithm (TAD) to dispatch requests in each tier. We evaluate sPARE on web serving and searching applications, i.e., MediaWiki and Solr, the former deployed on our private cloud and the latter on Amazon EC2. Our results based on various interference patterns and traffic loads show that sPARE is able to improve the tail latency of MediaWiki and Solr by a factor of almost 2.7x and 2.9x, respectively.
2019
Marco Aldinucci, Maurizio Drocco, Claudia Misale, Guy Tremblay
Languages for Big Data analysis Book Chapter
In: Sakr, Sherif, Zomaya, Albert (Ed.): Encyclopedia of Big Data Technologies, Springer International Publishing, Cham, 2019, ISBN: 978-3-319-63962-8.
Abstract | Links | BibTeX | Tags: parallel
@inbook{bigdata:encyclopedia:18,
title = {Languages for Big Data analysis},
author = {Marco Aldinucci and Maurizio Drocco and Claudia Misale and Guy Tremblay},
editor = {Sherif Sakr and Albert Zomaya},
url = {https://iris.unito.it/retrieve/handle/2318/1668051/413363/2019_bigdataframeworks_enc.pdf},
doi = {10.1007/978-3-319-63962-8_142-1},
isbn = {978-3-319-63962-8},
year = {2019},
date = {2019-01-01},
booktitle = {Encyclopedia of Big Data Technologies},
publisher = {Springer International Publishing},
address = {Cham},
abstract = {In this chapter, some of the most common tools for Big Data analytics are surveyed, inter-alia, Apache Spark, Flink, Storm, and Beam. They are compared against well-defined features concerning programming model (language expressivity and semantics), and execution model (parallel behaviour and run-time support). The implementation of a running example is provided for all of them.},
keywords = {parallel},
pubstate = {published},
tppubtype = {inbook}
}
In this chapter, some of the most common tools for Big Data analytics are surveyed, inter-alia, Apache Spark, Flink, Storm, and Beam. They are compared against well-defined features concerning programming model (language expressivity and semantics), and execution model (parallel behaviour and run-time support). The implementation of a running example is provided for all of them.
2008
Marco Aldinucci, Gabriel Antoniu, Marco Danelutto, Mathieu Jan
Fault-Tolerant Data Sharing for High-level Grid Programming: A Hierarchical Storage Architecture Book Section
In: Bubak, Marian, Gorlatch, Sergei, Priol, Thierry (Ed.): Achievements in European Research on Grid Systems, pp. 67–81, Springer, Kraków, Poland, 2008, ISBN: 978-0-387-72811-7.
Abstract | Links | BibTeX | Tags: parallel
@incollection{assist:juxmem:IW_book:07,
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/2007_IW06_book_juxadhocmem.pdf},
doi = {10.1007/978-0-387-72812-4_6},
isbn = {978-0-387-72811-7},
year = {2008},
date = {2008-11-01},
booktitle = {Achievements in European Research on Grid Systems},
pages = {67–81},
publisher = {Springer},
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 = {parallel},
pubstate = {published},
tppubtype = {incollection}
}
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, Marco Danelutto
Securing skeletal systems with limited performance penalty: the Muskel experience Journal Article
In: Journal of Systems Architecture, vol. 54, no. 9, pp. 868–876, 2008.
Abstract | Links | BibTeX | Tags: parallel
@article{security:jsa:07,
title = {Securing skeletal systems with limited performance penalty: the Muskel experience},
author = {Marco Aldinucci and Marco Danelutto},
url = {http://calvados.di.unipi.it/storage/paper_files/2008_security_JSA.pdf},
doi = {10.1016/j.sysarc.2008.02.008},
year = {2008},
date = {2008-09-01},
journal = {Journal of Systems Architecture},
volume = {54},
number = {9},
pages = {868–876},
publisher = {Elsevier},
abstract = {Algorithmic skeletons have been exploited to implement several parallel programming environments, targeting workstation clusters as well as workstation networks and computational grids. When targeting non-dedicated clusters, workstation networks and grids, security has to be taken adequately into account in order to guarantee both code and data confidentiality and integrity. However, introducing security is usually an expensive activity, both in terms of the effort required to managed security mechanisms and in terms of the time spent performing security related activities at run time.We discuss the cost of security introduction as well as how some features typical of skeleton technology can be exploited to improve the efficiency code and data securing in a typical skeleton based parallel programming environment and we evaluate the performance cost of security mechanisms implemented exploiting state of the art tools. In particular, 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 involving remote, unreliable nodes and we evaluate the cost of such mechanisms. Also, we consider the implications on the computational grains needed to scale secure and insecure skeletal computations.},
keywords = {parallel},
pubstate = {published},
tppubtype = {article}
}
Algorithmic skeletons have been exploited to implement several parallel programming environments, targeting workstation clusters as well as workstation networks and computational grids. When targeting non-dedicated clusters, workstation networks and grids, security has to be taken adequately into account in order to guarantee both code and data confidentiality and integrity. However, introducing security is usually an expensive activity, both in terms of the effort required to managed security mechanisms and in terms of the time spent performing security related activities at run time.We discuss the cost of security introduction as well as how some features typical of skeleton technology can be exploited to improve the efficiency code and data securing in a typical skeleton based parallel programming environment and we evaluate the performance cost of security mechanisms implemented exploiting state of the art tools. In particular, 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 involving remote, unreliable nodes and we evaluate the cost of such mechanisms. Also, we consider the implications on the computational grains needed to scale secure and insecure skeletal computations.
Marco Aldinucci, Sonia Campa, Marco Danelutto, Patrizio Dazzi, Peter Kilpatrick, Domenico Laforenza, Nicola Tonellotto
Behavioural skeletons for component autonomic management on grids Book Section
In: Danelutto, Marco, Frangopoulou, Paraskevi, Getov, Vladimir (Ed.): Making Grids Work, pp. 3–16, Springer, 2008, ISBN: 978-0-387-78447-2.
Abstract | Links | BibTeX | Tags: parallel
@incollection{beske:cg_book:08,
title = {Behavioural skeletons for component autonomic management on grids},
author = {Marco Aldinucci and Sonia Campa and Marco Danelutto and Patrizio Dazzi and Peter Kilpatrick and Domenico Laforenza and Nicola Tonellotto},
editor = {Marco Danelutto and Paraskevi Frangopoulou and Vladimir Getov},
url = {http://calvados.di.unipi.it/storage/paper_files/2007_beske_cg_crete_book.pdf},
doi = {10.1007/978-0-387-78448-9_1},
isbn = {978-0-387-78447-2},
year = {2008},
date = {2008-08-01},
booktitle = {Making Grids Work},
pages = {3–16},
publisher = {Springer},
chapter = {Component Programming Models},
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 = {parallel},
pubstate = {published},
tppubtype = {incollection}
}
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, Anne Benoit
Automatic mapping of ASSIST applications using process algebra Journal Article
In: Parallel Processing Letters, vol. 18, no. 1, pp. 175–188, 2008, ISSN: 0129-6264.
Abstract | Links | BibTeX | Tags: parallel
@article{assist:pepa:ppl:08,
title = {Automatic mapping of ASSIST applications using process algebra},
author = {Marco Aldinucci and Anne Benoit},
url = {http://calvados.di.unipi.it/storage/paper_files/2008_pepa_ppl.pdf},
doi = {10.1142/S0129626408003302},
issn = {0129-6264},
year = {2008},
date = {2008-03-01},
journal = {Parallel Processing Letters},
volume = {18},
number = {1},
pages = {175–188},
abstract = {Grid technologies aim to harness the computational capabilities of widely distributed collections of computers. Due to the heterogeneous and dynamic nature of the set of grid resources, 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.},
keywords = {parallel},
pubstate = {published},
tppubtype = {article}
}
Grid technologies aim to harness the computational capabilities of widely distributed collections of computers. Due to the heterogeneous and dynamic nature of the set of grid resources, 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.
Marco Aldinucci, Marco Danelutto, Peter Kilpatrick, Patrizio Dazzi
From Orc Models to Distributed Grid Java code Book Section
In: Gorlatch, Sergei, Fragopoulou, Paraskevi, Priol, Thierry (Ed.): Grid Computing: Achievements and Prospects, pp. 13–24, Springer, 2008, ISBN: 978-0-387-09456-4.
Abstract | Links | BibTeX | Tags: parallel
@incollection{orc:IW_book: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_book_O2J.pdf},
doi = {10.1007/978-0-387-09457-1_2},
isbn = {978-0-387-09456-4},
year = {2008},
date = {2008-01-01},
booktitle = {Grid Computing: Achievements and Prospects},
pages = {13–24},
publisher = {Springer},
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 inOrc. 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 aModel Driven Engineering approach to grid application development.},
keywords = {parallel},
pubstate = {published},
tppubtype = {incollection}
}
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 inOrc. 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 aModel Driven Engineering approach to grid application development.
2007
Marco Aldinucci, Marco Danelutto, Patrizio Dazzi
MUSKEL: an expandable skeleton environment Journal Article
In: Scalable Computing: Practice and Experience, vol. 8, no. 4, pp. 325–341, 2007.
Abstract | Links | BibTeX | Tags: parallel
@article{muskel:SCPE:07,
title = {MUSKEL: an expandable skeleton environment},
author = {Marco Aldinucci and Marco Danelutto and Patrizio Dazzi},
url = {http://www.scpe.org/index.php/scpe/article/view/429},
year = {2007},
date = {2007-12-01},
journal = {Scalable Computing: Practice and Experience},
volume = {8},
number = {4},
pages = {325–341},
abstract = {Programming models based on algorithmic skeletons promise to raise the level of abstraction perceived by programmers when implementing parallel applications, while guaranteeing good performance figures. At the same time, however, they restrict the freedom of programmers to implement arbitrary parallelism exploitation patterns. In fact, efficiency is achieved by restricting the parallelism exploitation patterns provided to the programmer to the useful ones for which efficient implementations, as well as useful and efficient compositions, are known. In this work we introduce muskel, a full Java library targeting workstation clusters, networks and grids and providing the programmers with a skeleton based parallel programming environment. muskel is implemented exploiting (macro) data flow technology, rather than the more usual skeleton technology relying on the use of implementation templates. Using data flow, muskel easily and efficiently implements both classical, predefined skeletons, and user-defined parallelism exploitation patterns. This provides a means to overcome some of the problems that Cole identified in his skeleton ``manifesto'' as the issues impairing skeleton success in the parallel programming arena. We discuss fully how user-defined skeletons are supported by exploiting a data flow implementation, experimental results and we also discuss extensions supporting the further characterization of skeletons with non-functional properties, such as security, through the use of Aspect Oriented Programming and annotations.},
keywords = {parallel},
pubstate = {published},
tppubtype = {article}
}
Programming models based on algorithmic skeletons promise to raise the level of abstraction perceived by programmers when implementing parallel applications, while guaranteeing good performance figures. At the same time, however, they restrict the freedom of programmers to implement arbitrary parallelism exploitation patterns. In fact, efficiency is achieved by restricting the parallelism exploitation patterns provided to the programmer to the useful ones for which efficient implementations, as well as useful and efficient compositions, are known. In this work we introduce muskel, a full Java library targeting workstation clusters, networks and grids and providing the programmers with a skeleton based parallel programming environment. muskel is implemented exploiting (macro) data flow technology, rather than the more usual skeleton technology relying on the use of implementation templates. Using data flow, muskel easily and efficiently implements both classical, predefined skeletons, and user-defined parallelism exploitation patterns. This provides a means to overcome some of the problems that Cole identified in his skeleton ``manifesto'' as the issues impairing skeleton success in the parallel programming arena. We discuss fully how user-defined skeletons are supported by exploiting a data flow implementation, experimental results and we also discuss extensions supporting the further characterization of skeletons with non-functional properties, such as security, through the use of Aspect Oriented Programming and annotations.
Marco Aldinucci, Marco Danelutto
Skeleton based parallel programming: functional and parallel semantic in a single shot Journal Article
In: Computer Languages, Systems and Structures, vol. 33, no. 3-4, pp. 179–192, 2007.
Abstract | Links | BibTeX | Tags: parallel
@article{lithium:sem:CLSS,
title = {Skeleton based parallel programming: functional and parallel semantic in a single shot},
author = {Marco Aldinucci and Marco Danelutto},
url = {http://calvados.di.unipi.it/storage/paper_files/2005_semantics_CLSS.pdf},
doi = {10.1016/j.cl.2006.07.004},
year = {2007},
date = {2007-10-01},
journal = {Computer Languages, Systems and Structures},
volume = {33},
number = {3-4},
pages = {179–192},
abstract = {Semantics of skeleton-based parallel programming languages comes usually as two distinct items: a functional semantics, modeling the function computed by the skeleton program, and a parallel semantics describing the ways used to exploit parallelism during the execution of the skeleton program. The former is usually expressed using some kind of semantic formalism, while the latter is almost always given in an informal way. Such a separation of functional and parallel semantics seriously impairs the possibility of programmers to use the semantic tools to prove properties of programs. In this work, we show how a formal semantic framework can be set up that handles both functional and parallel aspects of skeleton-based parallel programs. The framework is based on a labeled transition system. We show how different properties related to skeleton programs can be proved using such a system. We use Lithium, a skeleton-based full Java parallel programming environment, as the case study.},
keywords = {parallel},
pubstate = {published},
tppubtype = {article}
}
Semantics of skeleton-based parallel programming languages comes usually as two distinct items: a functional semantics, modeling the function computed by the skeleton program, and a parallel semantics describing the ways used to exploit parallelism during the execution of the skeleton program. The former is usually expressed using some kind of semantic formalism, while the latter is almost always given in an informal way. Such a separation of functional and parallel semantics seriously impairs the possibility of programmers to use the semantic tools to prove properties of programs. In this work, we show how a formal semantic framework can be set up that handles both functional and parallel aspects of skeleton-based parallel programs. The framework is based on a labeled transition system. We show how different properties related to skeleton programs can be proved using such a system. We use Lithium, a skeleton-based full Java parallel programming environment, as the case study.
Marco Aldinucci, Marco Danelutto, Peter Kilpatrick
Management in distributed systems: a semi-formal approach Proceedings Article
In: Kermarrec, A. -M., Bougé, L., Priol, T. (Ed.): Proc. of 13th Intl. Euro-Par 2007 Parallel Processing, pp. 651–661, Springer, Rennes, France, 2007, ISBN: 978-3-540-74465-8.
Abstract | Links | BibTeX | Tags: parallel, semantics
@inproceedings{orc:europar:07,
title = {Management in distributed systems: a semi-formal approach},
author = {Marco Aldinucci and Marco Danelutto and Peter Kilpatrick},
editor = {A. -M. Kermarrec and L. Bougé and T. Priol},
url = {http://calvados.di.unipi.it/storage/paper_files/2007_orc_europar.pdf},
doi = {10.1007/978-3-540-74466-5},
isbn = {978-3-540-74465-8},
year = {2007},
date = {2007-08-01},
booktitle = {Proc. of 13th Intl. Euro-Par 2007 Parallel Processing},
volume = {4641},
pages = {651–661},
publisher = {Springer},
address = {Rennes, France},
series = {LNCS},
abstract = {The reverse engineering of a skeleton based programming environment and redesign to distribute management activities of the system and thereby remove a potential single point of failure is considered. The Orc notation is used to facilitate abstraction of the design and analysis of its properties. It is argued that Orc is particularly suited to this role as this type of management is essentially an orchestration activity. The Orc specification of the original version of the system is modified via a series of semi-formally justified derivation steps to obtain a specification of the decentralized management version which is then used as a basis for its implementation. Analysis of the two specifications allows qualitative prediction of the expected performance of the derived version with respect to the original, and this prediction is borne out in practice.},
keywords = {parallel, semantics},
pubstate = {published},
tppubtype = {inproceedings}
}
The reverse engineering of a skeleton based programming environment and redesign to distribute management activities of the system and thereby remove a potential single point of failure is considered. The Orc notation is used to facilitate abstraction of the design and analysis of its properties. It is argued that Orc is particularly suited to this role as this type of management is essentially an orchestration activity. The Orc specification of the original version of the system is modified via a series of semi-formally justified derivation steps to obtain a specification of the decentralized management version which is then used as a basis for its implementation. Analysis of the two specifications allows qualitative prediction of the expected performance of the derived version with respect to the original, and this prediction is borne out in practice.
Marco Aldinucci, Sonia Campa, Marco Danelutto, Patrizio Dazzi, Peter Kilpatrick, Domenico Laforenza, Nicola Tonellotto
Behavioural skeletons for component autonomic management on grids Proceedings Article
In: CoreGRID Workshop on Grid Programming Model, Grid and P2P Systems Architecture, Grid Systems, Tools and Environments, Heraklion, Crete, Greece, 2007.
Abstract | Links | BibTeX | Tags: parallel
@inproceedings{beske:cg:heraklion:07,
title = {Behavioural skeletons for component autonomic management on grids},
author = {Marco Aldinucci and Sonia Campa and Marco Danelutto and Patrizio Dazzi and Peter Kilpatrick and Domenico Laforenza and Nicola Tonellotto},
url = {http://compass2.di.unipi.it/TR/Files/TR-07-12.pdf.gz},
year = {2007},
date = {2007-06-01},
booktitle = {CoreGRID Workshop on Grid Programming Model, Grid and P2P Systems Architecture, Grid Systems, Tools and Environments},
address = {Heraklion, Crete, Greece},
abstract = {We present behavioural skeletons for the CoreGRID Component Model, which are an abstraction aimed at simplifying the development of GCM-based self-management applications. Behavioural skeletons abstract component self-managent in component-based design as design patterns abstract class design in classic OO development. As here we just wish to introduce the behavioural skeleton framework, emphasis is placed on general skeleton structure rather than on their autonomic management policies.},
keywords = {parallel},
pubstate = {published},
tppubtype = {inproceedings}
}
We present behavioural skeletons for the CoreGRID Component Model, which are an abstraction aimed at simplifying the development of GCM-based self-management applications. Behavioural skeletons abstract component self-managent in component-based design as design patterns abstract class design in classic OO development. As here we just wish to introduce the behavioural skeleton framework, emphasis is placed on general skeleton structure rather than on their autonomic management policies.
Marco Aldinucci, Anne Benoit
Towards the Automatic Mapping of ASSIST Applications for the Grid Book Section
In: Gorlatch, Sergei, Danelutto, Marco (Ed.): Integrated Research in Grid Computing, pp. 73–87, Springer, 2007, ISBN: 978-0-387-47656-8.
Abstract | Links | BibTeX | Tags: parallel
@incollection{assist:pepa:IW_book:06,
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_book_pepa.pdf},
doi = {10.1007/978-0-387-47658-2_6},
isbn = {978-0-387-47656-8},
year = {2007},
date = {2007-01-01},
booktitle = {Integrated Research in Grid Computing},
pages = {73–87},
publisher = {Springer},
series = {CoreGRID},
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 = {parallel},
pubstate = {published},
tppubtype = {incollection}
}
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.
Marcelo Pasin, Pierre Kuonen, Marco Danelutto, Marco Aldinucci
Skeleton Parallel Programming and Parallel Objects Book Section
In: Gorlatch, Sergei, Danelutto, Marco (Ed.): Integrated Research in Grid Computing, pp. 59–71, Springer, 2007, ISBN: 978-0-387-47656-8.
Abstract | Links | BibTeX | Tags: parallel
@incollection{pasin:IW_book:06,
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_book_popc.pdf},
doi = {10.1007/978-0-387-47658-2_5},
isbn = {978-0-387-47656-8},
year = {2007},
date = {2007-01-01},
booktitle = {Integrated Research in Grid Computing},
pages = {59–71},
publisher = {Springer},
series = {CoreGRID},
abstract = {This paper describes 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, 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. The text explains how GEA, the ASSIST deployer can be considered as the basis for the integration of such different systems. An architecture is proposed, extending the existing tools to work together. The current status of integration of the two environments is discussed, along with the expected results and fallouts on the two programming environments.},
keywords = {parallel},
pubstate = {published},
tppubtype = {incollection}
}
This paper describes 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, 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. The text explains how GEA, the ASSIST deployer can be considered as the basis for the integration of such different systems. An architecture is proposed, extending the existing tools to work together. The current status of integration of the two environments is discussed, along with the expected results and fallouts on the two programming environments.
2006
Marco Aldinucci, Francoise André, Jérémy Buisson, Sonia Campa, Massimo Coppola, Marco Danelutto, Corrado Zoccolo
Parallel program/component adaptivity management 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. 89–96, John von Neumann Institute for Computing, Germany, 2006.
Abstract | Links | BibTeX | Tags: parallel
@inproceedings{adaptivity:parco:05,
title = {Parallel program/component adaptivity management},
author = {Marco Aldinucci and Francoise André and Jérémy Buisson and Sonia Campa and Massimo Coppola and Marco Danelutto and Corrado Zoccolo},
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_adaptivity_parco.pdf},
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 = {89–96},
publisher = {John von Neumann Institute for Computing},
address = {Germany},
series = {NIC},
abstract = {Grid computing platforms require to handle dynamic behaviour of computing resources within complex parallel applications. We introduce a formalization of adaptive behaviour that separates the abstract model of the application from the implementation design. We exemplify the abstract adaptation schema on two applications, and we show how two quite different approaches to adaptivity, the ASSIST environment and the AFPAC framework, easily map to this common schema.},
keywords = {parallel},
pubstate = {published},
tppubtype = {inproceedings}
}
Grid computing platforms require to handle dynamic behaviour of computing resources within complex parallel applications. We introduce a formalization of adaptive behaviour that separates the abstract model of the application from the implementation design. We exemplify the abstract adaptation schema on two applications, and we show how two quite different approaches to adaptivity, the ASSIST environment and the AFPAC framework, easily map to this common schema.
Marco Aldinucci, Marco Danelutto, Gianni Giaccherini, Massimo Torquati, Marco Vanneschi
Towards a distributed scalable data service for the grid 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. 73–80, John von Neumann Institute for Computing, Germany, 2006.
Abstract | Links | BibTeX | Tags: parallel
@inproceedings{adhoc:parco:05,
title = {Towards a distributed scalable data service for the grid},
author = {Marco Aldinucci and Marco Danelutto and Gianni Giaccherini and Massimo Torquati 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 = {https://iris.unito.it/retrieve/handle/2318/60375/711125/2005_adhoc_parco.pdf},
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 = {73–80},
publisher = {John von Neumann Institute for Computing},
address = {Germany},
series = {NIC},
abstract = {ADHOC (Adaptive Distributed Herd of Object Caches) is a Grid-enabled, fast, scalable object repository providing programmers with a general storage module. We present three different software tools based on ADHOC: A parallel cache for Apache, a DSM, and a main memory parallel file system. We also show that these tools exhibit a considerable performance and speedup both in absolute figures and w.r.t. other software tools exploiting the same features.},
keywords = {parallel},
pubstate = {published},
tppubtype = {inproceedings}
}
ADHOC (Adaptive Distributed Herd of Object Caches) is a Grid-enabled, fast, scalable object repository providing programmers with a general storage module. We present three different software tools based on ADHOC: A parallel cache for Apache, a DSM, and a main memory parallel file system. We also show that these tools exhibit a considerable performance and speedup both in absolute figures and w.r.t. other software tools exploiting the same features.
Marco Aldinucci, Marco Danelutto
Algorithmic skeletons meeting grids Journal Article
In: Parallel Computing, vol. 32, no. 7, pp. 449–462, 2006.
Abstract | Links | BibTeX | Tags: parallel
@article{advske:pc:06,
title = {Algorithmic skeletons meeting grids},
author = {Marco Aldinucci and Marco Danelutto},
url = {http://calvados.di.unipi.it/storage/paper_files/2006_advske_PC.pdf},
doi = {10.1016/j.parco.2006.04.001},
year = {2006},
date = {2006-01-01},
journal = {Parallel Computing},
volume = {32},
number = {7},
pages = {449–462},
abstract = {In this work, we discuss an extension of the set of principles that should guide the future design and development of skeletal programming systems, as defined by Cole in his "pragmatic manifesto'" paper. The three further principles introduced are related to the ability to exploit existing sequential code as well as to the ability to target typical modern architectures, those made out of heterogeneous processing elements with dynamically varying availability, processing power and connectivity features such as grids or heterogeneous, non-dedicated clusters. We outline two skeleton based programming environments currently developed at our university and we discuss how these environments adhere to the proposed set of principles. Eventually, we outline how some other relevant, well-known skeleton environments conform to the same set of principles.},
keywords = {parallel},
pubstate = {published},
tppubtype = {article}
}
In this work, we discuss an extension of the set of principles that should guide the future design and development of skeletal programming systems, as defined by Cole in his "pragmatic manifesto'" paper. The three further principles introduced are related to the ability to exploit existing sequential code as well as to the ability to target typical modern architectures, those made out of heterogeneous processing elements with dynamically varying availability, processing power and connectivity features such as grids or heterogeneous, non-dedicated clusters. We outline two skeleton based programming environments currently developed at our university and we discuss how these environments adhere to the proposed set of principles. Eventually, we outline how some other relevant, well-known skeleton environments conform to the same set of principles.
Marco Aldinucci, Massimo Coppola, Marco Danelutto, Nicola Tonellotto, Marco Vanneschi, Corrado Zoccolo
High level grid programming with ASSIST Journal Article
In: Computational Methods in Science and Technology, vol. 12, no. 1, pp. 21–32, 2006.
Abstract | Links | BibTeX | Tags: parallel
@article{assist:CMST:06,
title = {High level grid programming with ASSIST},
author = {Marco Aldinucci and Massimo Coppola and Marco Danelutto and Nicola Tonellotto and Marco Vanneschi and Corrado Zoccolo},
url = {http://calvados.di.unipi.it/storage/paper_files/2006_assist_j_cmst.pdf},
year = {2006},
date = {2006-01-01},
journal = {Computational Methods in Science and Technology},
volume = {12},
number = {1},
pages = {21–32},
abstract = {The development of efficient Grid applications usually requires writing huge portions of code directly at the level of abstraction provided by the underlying Grid middleware. In this work we discuss an alternative approach, raising the level of abstraction used when programming Grid applications. Our approach requires programmers just to describe in a qualitative way the kind of parallelism they want to express. Then, compiler tools, loader tools and run time system take complete care of running the application on a Grid target architecture. This allows to move most of the cumbersome tasks related to Grid targeting and management from programmer responsibility to tools. This paper introduces the structured parallel programming environment ASSIST, whose design is aimed at raising the level of abstraction in Grid programming and discusses how it can support transparent Grid programming while implementing Grid adaptivity.},
keywords = {parallel},
pubstate = {published},
tppubtype = {article}
}
The development of efficient Grid applications usually requires writing huge portions of code directly at the level of abstraction provided by the underlying Grid middleware. In this work we discuss an alternative approach, raising the level of abstraction used when programming Grid applications. Our approach requires programmers just to describe in a qualitative way the kind of parallelism they want to express. Then, compiler tools, loader tools and run time system take complete care of running the application on a Grid target architecture. This allows to move most of the cumbersome tasks related to Grid targeting and management from programmer responsibility to tools. This paper introduces the structured parallel programming environment ASSIST, whose design is aimed at raising the level of abstraction in Grid programming and discusses how it can support transparent Grid programming while implementing Grid adaptivity.
2005
Marco Aldinucci, Francoise André, Jérémy Buisson, Sonia Campa, Massimo Coppola, Marco Danelutto, Corrado Zoccolo
Parallel program/component adaptivity management Proceedings Article
In: Gorlatch, Sergei, Danelutto, Marco (Ed.): Proc. of the Integrated Research in Grid Computing Workshop, pp. 95–104, Università di Pisa, Dipartimento di Informatica, Pisa, Italy, 2005.
Abstract | Links | BibTeX | Tags: parallel
@inproceedings{adaptivity:IW:05,
title = {Parallel program/component adaptivity management},
author = {Marco Aldinucci and Francoise André and Jérémy Buisson and Sonia Campa and Massimo Coppola and Marco Danelutto and Corrado Zoccolo},
editor = {Sergei Gorlatch and Marco Danelutto},
url = {http://calvados.di.unipi.it/storage/paper_files/2006_IW_adapt.pdf},
year = {2005},
date = {2005-11-01},
booktitle = {Proc. of the Integrated Research in Grid Computing Workshop},
volume = {TR-05-22},
pages = {95–104},
publisher = {Università di Pisa, Dipartimento di Informatica},
address = {Pisa, Italy},
abstract = {Grid computing platforms require to handle dynamic behaviour of computing resources within complex parallel applications. We introduce a formalization of adaptive behaviour that separates the ab- stract model of the application from the implementation design. We ex- emplify the abstract adaptation schema on two applications, and we show how two quite different approaches to adaptivity, the ASSIST environ- ment and the AFPAC framework, easily map to this common schema.},
keywords = {parallel},
pubstate = {published},
tppubtype = {inproceedings}
}
Grid computing platforms require to handle dynamic behaviour of computing resources within complex parallel applications. We introduce a formalization of adaptive behaviour that separates the ab- stract model of the application from the implementation design. We ex- emplify the abstract adaptation schema on two applications, and we show how two quite different approaches to adaptivity, the ASSIST environ- ment and the AFPAC framework, easily map to this common schema.
Marco Aldinucci, Marco Danelutto, Jan Dünnweber, Sergei Gorlatch
Optimization techniques for skeletons on grids Book Section
In: Grandinetti, L. (Ed.): Grid Computing and New Frontiers of High Performance Processing, vol. 14, pp. 255–273, Elsevier, 2005, ISSN: 09275452.
Abstract | Links | BibTeX | Tags: parallel
@incollection{vigoni:fut_rmi:book:05,
title = {Optimization techniques for skeletons on grids},
author = {Marco Aldinucci and Marco Danelutto and Jan Dünnweber and Sergei Gorlatch},
editor = {L. Grandinetti},
url = {http://calvados.di.unipi.it/storage/paper_files/2005_LithiumFutRMI_book.pdf},
doi = {10.1016/S0927-5452(05)80014-0},
issn = {09275452},
year = {2005},
date = {2005-10-01},
booktitle = {Grid Computing and New Frontiers of High Performance Processing},
volume = {14},
pages = {255–273},
publisher = {Elsevier},
chapter = {2},
series = {Advances in Parallel Computing},
abstract = {Skeletons are common patterns of parallelism, such as farm and pipeline, that can be abstracted and offered to the application programmer as programming primitives. We describe the use and implementation of skeletons on emerging computational grids, with the skeleton system Lithium, based on Java and RMI, as our reference programming syttem. Our main contribution is the exploration of optimization techniques for implementing skeletons on grids based on an optimized, future-based RMI mechanism, which we integrate into the macro-dataflow evaluation mechanism of Lithium. We discuss three optimizations: 1) a lookahead mechanism that allows to process multiple tasks concurrently at each grid server and thereby increases the overall degree of parallelism, 2) a lazy taskbinding technique that reduces interactions between grid servers and the task dispatcher, and 3) dynamic improvements that optimize the collecting of results and the work-load balancing. We report experimental results that demonstrate the improvements due to our optimizations on various testbeds, including a heterogeneous grid-like environment.},
keywords = {parallel},
pubstate = {published},
tppubtype = {incollection}
}
Skeletons are common patterns of parallelism, such as farm and pipeline, that can be abstracted and offered to the application programmer as programming primitives. We describe the use and implementation of skeletons on emerging computational grids, with the skeleton system Lithium, based on Java and RMI, as our reference programming syttem. Our main contribution is the exploration of optimization techniques for implementing skeletons on grids based on an optimized, future-based RMI mechanism, which we integrate into the macro-dataflow evaluation mechanism of Lithium. We discuss three optimizations: 1) a lookahead mechanism that allows to process multiple tasks concurrently at each grid server and thereby increases the overall degree of parallelism, 2) a lazy taskbinding technique that reduces interactions between grid servers and the task dispatcher, and 3) dynamic improvements that optimize the collecting of results and the work-load balancing. We report experimental results that demonstrate the improvements due to our optimizations on various testbeds, including a heterogeneous grid-like environment.
2004
Marco Aldinucci, Massimo Torquati
Accelerating apache farms through ad-HOC distributed scalable object repository Proceedings Article
In: Danelutto, Marco, Vanneschi, Marco, Laforenza, Domenico (Ed.): Proc. of 10th Intl. Euro-Par 2004 Parallel Processing, pp. 596–605, Springer, 2004.
Abstract | Links | BibTeX | Tags: parallel
@inproceedings{assist:adhoc:europar:04,
title = {Accelerating apache farms through ad-HOC distributed scalable object repository},
author = {Marco Aldinucci and Massimo Torquati},
editor = {Marco Danelutto and Marco Vanneschi and Domenico Laforenza},
url = {http://calvados.di.unipi.it/storage/paper_files/2004_hoc_europar.pdf},
doi = {10.1007/978-3-540-27866-5_78},
year = {2004},
date = {2004-08-01},
booktitle = {Proc. of 10th Intl. Euro-Par 2004 Parallel Processing},
volume = {3149},
pages = {596–605},
publisher = {Springer},
series = {LNCS},
abstract = {We present HOC: a fast, scalable object repository providing programmers with a general storage module. hoc may be used to implement DSMs as well as distributed cache subsystems. HOC is composed of a set of hot-pluggable cooperating processes that may sustain a close to optimal network traffic rate. We designed an HOC-based Web cache that extends the Apache Web server and remarkably improves Apache farms performances with no modification to the Apache core code.},
keywords = {parallel},
pubstate = {published},
tppubtype = {inproceedings}
}
We present HOC: a fast, scalable object repository providing programmers with a general storage module. hoc may be used to implement DSMs as well as distributed cache subsystems. HOC is composed of a set of hot-pluggable cooperating processes that may sustain a close to optimal network traffic rate. We designed an HOC-based Web cache that extends the Apache Web server and remarkably improves Apache farms performances with no modification to the Apache core code.
Marco Aldinucci, Sonia Campa, Massimo Coppola, Silvia Magini, Paolo Pesciullesi, Laura Potiti, Roberto Ravazzolo, Massimo Torquati, Corrado Zoccolo
Targeting heterogeneous architectures in ASSIST: Experimental results Proceedings Article
In: Danelutto, Marco, Vanneschi, Marco, Laforenza, Domenico (Ed.): Proc. of 10th Intl. Euro-Par 2004 Parallel Processing, pp. 638–643, Springer, 2004, ISBN: 978-3-540-22924-7.
Abstract | Links | BibTeX | Tags: parallel
@inproceedings{assist:hetero:europar:04,
title = {Targeting heterogeneous architectures in ASSIST: Experimental results},
author = {Marco Aldinucci and Sonia Campa and Massimo Coppola and Silvia Magini and Paolo Pesciullesi and Laura Potiti and Roberto Ravazzolo and Massimo Torquati and Corrado Zoccolo},
editor = {Marco Danelutto and Marco Vanneschi and Domenico Laforenza},
url = {http://calvados.di.unipi.it/storage/paper_files/2004_hetero_europar.pdf},
doi = {10.1142/S0129626412400063},
isbn = {978-3-540-22924-7},
year = {2004},
date = {2004-08-01},
booktitle = {Proc. of 10th Intl. Euro-Par 2004 Parallel Processing},
volume = {3149},
pages = {638–643},
publisher = {Springer},
series = {LNCS},
abstract = {We describe how the ASSIST parallel programming environment can be used to run parallel programs on collections of heterogeneous workstations and evaluate the scalability of one task-farm real application and a data-parallel benchmark, comparing the actual performance figures measured when using homogeneous and heterogeneous workstation clusters. We describe also the ASSIST approach to heterogeneous distributed shared memory and provide preliminary performance figures of the current implementation.},
keywords = {parallel},
pubstate = {published},
tppubtype = {inproceedings}
}
We describe how the ASSIST parallel programming environment can be used to run parallel programs on collections of heterogeneous workstations and evaluate the scalability of one task-farm real application and a data-parallel benchmark, comparing the actual performance figures measured when using homogeneous and heterogeneous workstation clusters. We describe also the ASSIST approach to heterogeneous distributed shared memory and provide preliminary performance figures of the current implementation.
2003
Marco Aldinucci
eskimo: experimenting with Skeletons in the Shared Address Model Journal Article
In: Parallel Processing Letters, vol. 13, no. 3, pp. 449–460, 2003, ISSN: 0129-6264.
Abstract | Links | BibTeX | Tags: parallel
@article{eskimo:PPL:03,
title = {eskimo: experimenting with Skeletons in the Shared Address Model},
author = {Marco Aldinucci},
url = {http://calvados.di.unipi.it/storage/paper_files/2003_eskimo_ppl.pdf},
doi = {10.1142/S0129626403001410},
issn = {0129-6264},
year = {2003},
date = {2003-09-01},
journal = {Parallel Processing Letters},
volume = {13},
number = {3},
pages = {449–460},
abstract = {We discuss the lack of expressivity in some skeleton-based parallel programmingframeworks. The problem is further exacerbated when approaching irregular problems and dealing with dynamic data structures. Shared memory programming has been argued to have substantial ease of programming advantages for this class of problems. We present the eskimo library which represents an attempt to merge the two programming models by introducing skeletons in a shared memory framework.},
keywords = {parallel},
pubstate = {published},
tppubtype = {article}
}
We discuss the lack of expressivity in some skeleton-based parallel programmingframeworks. The problem is further exacerbated when approaching irregular problems and dealing with dynamic data structures. Shared memory programming has been argued to have substantial ease of programming advantages for this class of problems. We present the eskimo library which represents an attempt to merge the two programming models by introducing skeletons in a shared memory framework.
Marco Aldinucci, Sonia Campa, Pierpaolo Ciullo, Massimo Coppola, Marco Danelutto, Paolo Pesciullesi, Roberto Ravazzolo, Massimo Torquati, Marco Vanneschi, Corrado Zoccolo
ASSIST demo: a high level, high performance, portable, structured parallel programming environment at work Proceedings Article
In: Kosch, H., Böszörményi, L., Hellwagner, H. (Ed.): Proc. of 9th Intl. Euro-Par 2003 Parallel Processing, pp. 1295–1300, Springer, Klagenfurt, Austria, 2003.
Abstract | Links | BibTeX | Tags: parallel
@inproceedings{assist:demo:europar:03,
title = {ASSIST demo: a high level, high performance, portable, structured parallel programming environment at work},
author = {Marco Aldinucci and Sonia Campa and Pierpaolo Ciullo and Massimo Coppola and Marco Danelutto and Paolo Pesciullesi and Roberto Ravazzolo and Massimo Torquati and Marco Vanneschi and Corrado Zoccolo},
editor = {H. Kosch and L. Böszörményi and H. Hellwagner},
url = {http://calvados.di.unipi.it/storage/paper_files/2003_assist_demo_europar.pdf},
doi = {10.1007/978-3-540-45209-6_176},
year = {2003},
date = {2003-08-01},
booktitle = {Proc. of 9th Intl. Euro-Par 2003 Parallel Processing},
volume = {2790},
pages = {1295–1300},
publisher = {Springer},
address = {Klagenfurt, Austria},
series = {LNCS},
abstract = {This work summarizes the possibilities offered by parallel programming environment ASSIST by outlining some of the features that will be demonstrated at the conference demo session. We'll substantially show how this environment can be deployed on a Linux workstation network/cluster, how applications can be compiled and run using ASSIST and eventually, we'll discuss some ASSIST scalability and performance features. We'll also outline how the ASSIST environment can be used to target GRID architectures.},
keywords = {parallel},
pubstate = {published},
tppubtype = {inproceedings}
}
This work summarizes the possibilities offered by parallel programming environment ASSIST by outlining some of the features that will be demonstrated at the conference demo session. We'll substantially show how this environment can be deployed on a Linux workstation network/cluster, how applications can be compiled and run using ASSIST and eventually, we'll discuss some ASSIST scalability and performance features. We'll also outline how the ASSIST environment can be used to target GRID architectures.
Marco Aldinucci, Marco Danelutto, Paolo Teti
An advanced environment supporting structured parallel programming in Java Journal Article
In: Future Generation Computer Systems, vol. 19, no. 5, pp. 611–626, 2003.
Abstract | Links | BibTeX | Tags: parallel
@article{lithium:fgcs:03,
title = {An advanced environment supporting structured parallel programming in Java},
author = {Marco Aldinucci and Marco Danelutto and Paolo Teti},
url = {http://calvados.di.unipi.it/storage/paper_files/2003_lithium_fgcs.pdf},
doi = {10.1016/S0167-739X(02)00172-3},
year = {2003},
date = {2003-07-01},
journal = {Future Generation Computer Systems},
volume = {19},
number = {5},
pages = {611–626},
abstract = {In this work we present Lithium, a pure Java structured parallel programming environment based on skeletons (common, reusable and efficient parallelism exploitation patterns). Lithium is implemented as a Java package and represents both the first skeleton based programming environment in Java and the first complete skeleton based Java environment exploiting macro-data flow implementation techniques. Lithium supports a set of user code optimizations which are based on skeleton rewriting techniques. These optimizations improve both absolute performance and resource usage with respect to original user code. Parallel programs developed using the library run on any network of workstations provided the workstations support plain JRE. The paper describes the library implementation, outlines the optimization techniques used and eventually presents the performance results obtained on both synthetic and real applications.},
keywords = {parallel},
pubstate = {published},
tppubtype = {article}
}
In this work we present Lithium, a pure Java structured parallel programming environment based on skeletons (common, reusable and efficient parallelism exploitation patterns). Lithium is implemented as a Java package and represents both the first skeleton based programming environment in Java and the first complete skeleton based Java environment exploiting macro-data flow implementation techniques. Lithium supports a set of user code optimizations which are based on skeleton rewriting techniques. These optimizations improve both absolute performance and resource usage with respect to original user code. Parallel programs developed using the library run on any network of workstations provided the workstations support plain JRE. The paper describes the library implementation, outlines the optimization techniques used and eventually presents the performance results obtained on both synthetic and real applications.
2002
Marco Aldinucci
Automatic Program Transformation: The Meta Tool for Skeleton-based Languages Book Section
In: Gorlatch, Sergei, Lengauer, Christian (Ed.): Constructive Methods for Parallel Programming, pp. 59–78, Nova Science Publishers, NY, USA, 2002, ISBN: 1-59033-374-8.
Abstract | Links | BibTeX | Tags: parallel
@incollection{meta:CMPP:book:02,
title = {Automatic Program Transformation: The Meta Tool for Skeleton-based Languages},
author = {Marco Aldinucci},
editor = {Sergei Gorlatch and Christian Lengauer},
url = {http://calvados.di.unipi.it/storage/paper_files/2002_meta_book.a4.pdf},
isbn = {1-59033-374-8},
year = {2002},
date = {2002-01-01},
booktitle = {Constructive Methods for Parallel Programming},
pages = {59–78},
publisher = {Nova Science Publishers},
address = {NY, USA},
chapter = {5},
series = {Advances in Computation: Theory and Practice},
abstract = {Academic and commercial experience with skeleton-based systems has demonstrated the benefits of the approach but also the lack of methods and tools for algorithm design and performance prediction. We propose a (graphical) transformation tool based on a novel internal representation of programs that enables the user to effectively deal with program transformation. Given a skeleton-based language and a set of semantic-preserving transformation rules, the tool locates applicable transformations and provides performance estimates, thereby helping the programmer in navigating through the program refinement space.},
keywords = {parallel},
pubstate = {published},
tppubtype = {incollection}
}
Academic and commercial experience with skeleton-based systems has demonstrated the benefits of the approach but also the lack of methods and tools for algorithm design and performance prediction. We propose a (graphical) transformation tool based on a novel internal representation of programs that enables the user to effectively deal with program transformation. Given a skeleton-based language and a set of semantic-preserving transformation rules, the tool locates applicable transformations and provides performance estimates, thereby helping the programmer in navigating through the program refinement space.
2001
Marco Aldinucci, Sergei Gorlatch, Christian Lengauer, Susanna Pelagatti
Towards Parallel Programming by Transformation: The FAN Skeleton Framework Journal Article
In: Parallel Algorithms and Applications, vol. 16, no. 2-3, pp. 87–121, 2001.
Abstract | Links | BibTeX | Tags: parallel
@article{FAN:PPA:01,
title = {Towards Parallel Programming by Transformation: The FAN Skeleton Framework},
author = {Marco Aldinucci and Sergei Gorlatch and Christian Lengauer and Susanna Pelagatti},
url = {http://calvados.di.unipi.it/storage/paper_files/2001_FAN_paa.pdf},
doi = {10.1080/01495730108935268},
year = {2001},
date = {2001-03-01},
journal = {Parallel Algorithms and Applications},
volume = {16},
number = {2-3},
pages = {87–121},
abstract = {A Functional Abstract Notation (FAN) is proposed for the specification and design of parallel algorithms by means of skeletons - high-level patterns with parallel semantics. The main weakness of the current programming systems based on skeletons is that the user is still responsible for finding the most appropriate skeleton composition for a given application and a given parallel architecture. We describe a transformational framework for the development of skeletal programs which is aimed at filling this gap. The framework makes use of transformation rules which are semantic equivalences among skeleton compositions. For a given problem, an initial, possibly inefficient skeleton specification is refined by applying a sequence of transformations. Transformations are guided by a set of performance prediction models which forecast the behavior of each skeleton and the performance benefits of different rules. The design process is supported by a graphical tool which locates applicable transformations and provides performance estimates, thereby helping the programmer in navigating through the program refinement space. We give an overview of the FAN framework and exemplify its use with performance-directed program derivations for simple case studies. Our experience can be viewed as a first feasibility study of methods and tools for transformational, performance-directed parallel programming using skeletons.},
keywords = {parallel},
pubstate = {published},
tppubtype = {article}
}
A Functional Abstract Notation (FAN) is proposed for the specification and design of parallel algorithms by means of skeletons - high-level patterns with parallel semantics. The main weakness of the current programming systems based on skeletons is that the user is still responsible for finding the most appropriate skeleton composition for a given application and a given parallel architecture. We describe a transformational framework for the development of skeletal programs which is aimed at filling this gap. The framework makes use of transformation rules which are semantic equivalences among skeleton compositions. For a given problem, an initial, possibly inefficient skeleton specification is refined by applying a sequence of transformations. Transformations are guided by a set of performance prediction models which forecast the behavior of each skeleton and the performance benefits of different rules. The design process is supported by a graphical tool which locates applicable transformations and provides performance estimates, thereby helping the programmer in navigating through the program refinement space. We give an overview of the FAN framework and exemplify its use with performance-directed program derivations for simple case studies. Our experience can be viewed as a first feasibility study of methods and tools for transformational, performance-directed parallel programming using skeletons.
2000
Marco Aldinucci
The Meta Transformation Tool for Skeleton-Based Languages Proceedings Article
In: Gorlatch, S., Lengauer, C. (Ed.): Proc. of CMPP: Intl. Workshop on Constructive Methods for Parallel Programming, pp. 53–68, Fakultät für mathematik und informatik Uni. Passau, Germany, 2000.
Abstract | Links | BibTeX | Tags: parallel
@inproceedings{aldinuc:meta:00,
title = {The Meta Transformation Tool for Skeleton-Based Languages},
author = {Marco Aldinucci},
editor = {S. Gorlatch and C. Lengauer},
url = {http://calvados.di.unipi.it/storage/paper_files/2000_meta_cmpp.pdf},
year = {2000},
date = {2000-07-01},
booktitle = {Proc. of CMPP: Intl. Workshop on Constructive Methods for Parallel Programming},
pages = {53–68},
publisher = {Uni. Passau, Germany},
organization = {Fakultät für mathematik und informatik},
abstract = {Academic and commercial experience with skeleton-based systems has demonstrated the benefits of the approach but also the lack of methods and tools for algorithm design and performance prediction. We propose a (graphical) transformation tool based on a novel internal representation of programs that enables the user to effectively deal with program transformation. Given a skeleton-based language and a set of semantic-preserving transformation rules, the tool locates applicable transformations and provides performance estimates, thereby helping the programmer in navigating through the program refinement space.},
keywords = {parallel},
pubstate = {published},
tppubtype = {inproceedings}
}
Academic and commercial experience with skeleton-based systems has demonstrated the benefits of the approach but also the lack of methods and tools for algorithm design and performance prediction. We propose a (graphical) transformation tool based on a novel internal representation of programs that enables the user to effectively deal with program transformation. Given a skeleton-based language and a set of semantic-preserving transformation rules, the tool locates applicable transformations and provides performance estimates, thereby helping the programmer in navigating through the program refinement space.
1999
Marco Aldinucci, Marco Danelutto
Stream parallel skeleton optimization Proceedings Article
In: Proc. of PDCS: Intl. Conference on Parallel and Distributed Computing and Systems, pp. 955–962, IASTED ACTA press, Cambridge, Massachusetts, USA, 1999.
Abstract | Links | BibTeX | Tags: parallel
@inproceedings{pdcs:nf:99,
title = {Stream parallel skeleton optimization},
author = {Marco Aldinucci and Marco Danelutto},
url = {http://calvados.di.unipi.it/storage/paper_files/1999_NF_pdcs.pdf},
year = {1999},
date = {1999-11-01},
booktitle = {Proc. of PDCS: Intl. Conference on Parallel and Distributed Computing and Systems},
pages = {955–962},
publisher = {ACTA press},
address = {Cambridge, Massachusetts, USA},
organization = {IASTED},
abstract = {We discuss the properties of the composition of stream parallel skeletons such as pipelines and farms. By looking at the ideal performance figures assumed to hold for these skeletons, we show that any stream parallel skeleton composition can always be rewritten into an equivalent "normal form" skeleton composition, delivering a service time which is equal or even better to the service time of the original skeleton composition, and achieving a better utilization of the processors used. The normal form is defined as a single farm built around a sequential worker code. Experimental results are discussed that validate this normal form.},
keywords = {parallel},
pubstate = {published},
tppubtype = {inproceedings}
}
We discuss the properties of the composition of stream parallel skeletons such as pipelines and farms. By looking at the ideal performance figures assumed to hold for these skeletons, we show that any stream parallel skeleton composition can always be rewritten into an equivalent "normal form" skeleton composition, delivering a service time which is equal or even better to the service time of the original skeleton composition, and achieving a better utilization of the processors used. The normal form is defined as a single farm built around a sequential worker code. Experimental results are discussed that validate this normal form.
1998
Marco Aldinucci, Massimo Coppola, Marco Danelutto
Rewriting skeleton programs: How to evaluate the data-parallel stream-parallel tradeoff Proceedings Article
In: Gorlatch, S. (Ed.): Proc. of CMPP: Intl. Workshop on Constructive Methods for Parallel Programming, pp. 44–58, Fakultät für mathematik und informatik Uni. Passau, Germany, 1998.
Abstract | Links | BibTeX | Tags: parallel
@inproceedings{aldinuc:stream-data:98,
title = {Rewriting skeleton programs: How to evaluate the data-parallel stream-parallel tradeoff},
author = {Marco Aldinucci and Massimo Coppola and Marco Danelutto},
editor = {S. Gorlatch},
url = {http://calvados.di.unipi.it/storage/paper_files/1998_transf_cmpp.pdf},
year = {1998},
date = {1998-05-01},
booktitle = {Proc. of CMPP: Intl. Workshop on Constructive Methods for Parallel Programming},
pages = {44–58},
publisher = {Uni. Passau, Germany},
organization = {Fakultät für mathematik und informatik},
abstract = {Some skeleton based parallel programming models allow the programmer to use both data and stream parallel skeletons within the same program. It is known that particular skeleton nestings can be formally rewritten into different nestings that preserve the functional semantics. Indeed, the kind and possibly the amount of parallelism usefully exploitable may change while rewriting takes place. Here we discuss an original framework allowing the user (and/or the compiling tools) of a skeleton based parallel programming language to evaluate whether or not the transformation of a skeleton program is worthwhile in terms of the final program performance. We address, in particular, the evaluation of transformations exchanging data parallel and stream parallel skeleton subtrees.},
keywords = {parallel},
pubstate = {published},
tppubtype = {inproceedings}
}
Some skeleton based parallel programming models allow the programmer to use both data and stream parallel skeletons within the same program. It is known that particular skeleton nestings can be formally rewritten into different nestings that preserve the functional semantics. Indeed, the kind and possibly the amount of parallelism usefully exploitable may change while rewriting takes place. Here we discuss an original framework allowing the user (and/or the compiling tools) of a skeleton based parallel programming language to evaluate whether or not the transformation of a skeleton program is worthwhile in terms of the final program performance. We address, in particular, the evaluation of transformations exchanging data parallel and stream parallel skeleton subtrees.