Papers | Parallel Computing
2023
Adriano Marques Garcia, Dalvan Griebler, Claudio Schepke, Luiz Gustavo Fernandes
Micro-batch and data frequency for stream processing on multi-cores Journal Article
In: The Journal of Supercomputing, vol. 79, no. 8, pp. 9206-9244, 2023, ISBN: 1573-0484.
Abstract | Links | BibTeX | Tags: parallel
@article{GARCIA:JSuper:23,
title = {Micro-batch and data frequency for stream processing on multi-cores},
author = {Adriano Marques Garcia and Dalvan Griebler and Claudio Schepke and Luiz Gustavo Fernandes},
url = {https://iris.unito.it/retrieve/9328dbca-98ae-4ac5-b856-57c72db4444a/s11227-022-05024-y_preprint.pdf},
doi = {10.1007/s11227-022-05024-y},
isbn = {1573-0484},
year = {2023},
date = {2023-01-01},
journal = {The Journal of Supercomputing},
volume = {79},
number = {8},
pages = {9206-9244},
publisher = {Springer},
abstract = {Latency or throughput is often critical performance metrics in stream processing. Applications’ performance can fluctuate depending on the input stream. This unpredictability is due to the variety in data arrival frequency and size, complexity, and other factors. Researchers are constantly investigating new ways to mitigate the impact of these variations on performance with self-adaptive techniques involving elasticity or micro-batching. However, there is a lack of benchmarks capable of creating test scenarios to further evaluate these techniques. This work extends and improves the SPBench benchmarking framework to support dynamic micro-batching and data stream frequency management. We also propose a set of algorithms that generates the most commonly used frequency patterns for benchmarking stream processing in related work. It allows the creation of a wide variety of test scenarios. To validate our solution, we use SPBench to create custom benchmarks and evaluate the impact of micro-batching and data stream frequency on the performance of Intel TBB and FastFlow. These are two libraries that leverage stream parallelism for multi-core architectures. Our results demonstrated that our test cases did not benefit from micro-batches on multi-cores. For different data stream frequency configurations, TBB ensured the lowest latency, while FastFlow assured higher throughput in shorter pipelines.},
keywords = {parallel},
pubstate = {published},
tppubtype = {article}
}
Latency or throughput is often critical performance metrics in stream processing. Applications’ performance can fluctuate depending on the input stream. This unpredictability is due to the variety in data arrival frequency and size, complexity, and other factors. Researchers are constantly investigating new ways to mitigate the impact of these variations on performance with self-adaptive techniques involving elasticity or micro-batching. However, there is a lack of benchmarks capable of creating test scenarios to further evaluate these techniques. This work extends and improves the SPBench benchmarking framework to support dynamic micro-batching and data stream frequency management. We also propose a set of algorithms that generates the most commonly used frequency patterns for benchmarking stream processing in related work. It allows the creation of a wide variety of test scenarios. To validate our solution, we use SPBench to create custom benchmarks and evaluate the impact of micro-batching and data stream frequency on the performance of Intel TBB and FastFlow. These are two libraries that leverage stream parallelism for multi-core architectures. Our results demonstrated that our test cases did not benefit from micro-batches on multi-cores. For different data stream frequency configurations, TBB ensured the lowest latency, while FastFlow assured higher throughput in shorter pipelines.
2022
Christopher Stewart, Nathaniel Morris, Lydia Y. Chen, Robert Birke
Performance Modeling for Short-Term Cache Allocation Proceedings Article
In: Proceedings of the 51st International Conference on Parallel Processing (ICPP), pp. 31:1–31:11, ACM, 2022.
Abstract | Links | BibTeX | Tags: parallel
@inproceedings{icpp-stewart22,
title = {Performance Modeling for Short-Term Cache Allocation},
author = {Christopher Stewart and Nathaniel Morris and Lydia Y. Chen and Robert Birke},
url = {https://doi.org/10.1145/3545008.3545094},
doi = {10.1145/3545008.3545094},
year = {2022},
date = {2022-08-01},
booktitle = {Proceedings of the 51st International Conference on Parallel Processing (ICPP)},
pages = {31:1–31:11},
publisher = {ACM},
abstract = {Short-term cache allocation grants and then revokes access to processor cache lines dynamically. For online services, short-term allocation can speed up targeted query executions and free up cache lines reserved, but normally not needed, for performance. However, in collocated settings, short-term allocation can increase cache contention, slowing down collocated query executions. To offset slowdowns, collocated services may request short-term allocation more often, making the problem worse. Short-term allocation policies manage which queries receive cache allocations and when. In collocated settings, these policies should balance targeted query speedups against slowdowns caused by recurring cache contention. We present a model-driven approach that (1) predicts response time under a given policy, (2) explores competing policies and (3) chooses policies that yield low response time for all collocated services. Our approach profiles cache usage offline, characterizes the effects of cache allocation policies using deep learning techniques and devises novel performance models for short-term allocation with online services. We tested our approach using data processing, cloud, and high-performance computing benchmarks collocated on Intel processors equipped with Cache Allocation Technology. Our models predicted median response time with 11% absolute percent error. Short-term allocation policies found using our approach out performed state-of-the-art shared cache allocation policies by 1.2-2.3X.},
keywords = {parallel},
pubstate = {published},
tppubtype = {inproceedings}
}
Short-term cache allocation grants and then revokes access to processor cache lines dynamically. For online services, short-term allocation can speed up targeted query executions and free up cache lines reserved, but normally not needed, for performance. However, in collocated settings, short-term allocation can increase cache contention, slowing down collocated query executions. To offset slowdowns, collocated services may request short-term allocation more often, making the problem worse. Short-term allocation policies manage which queries receive cache allocations and when. In collocated settings, these policies should balance targeted query speedups against slowdowns caused by recurring cache contention. We present a model-driven approach that (1) predicts response time under a given policy, (2) explores competing policies and (3) chooses policies that yield low response time for all collocated services. Our approach profiles cache usage offline, characterizes the effects of cache allocation policies using deep learning techniques and devises novel performance models for short-term allocation with online services. We tested our approach using data processing, cloud, and high-performance computing benchmarks collocated on Intel processors equipped with Cache Allocation Technology. Our models predicted median response time with 11% absolute percent error. Short-term allocation policies found using our approach out performed state-of-the-art shared cache allocation policies by 1.2-2.3X.
Adriano Marques Garcia, Dalvan Griebler, Claudio Schepke, Luiz Gustavo Fernandes
Evaluating Micro-batch and Data Frequency for Stream Processing Applications on Multi-cores Proceedings Article
In: 30th Euromicro International Conference on Parallel, Distributed and Network-Based Processing (PDP), pp. 10-17, IEEE, Valladolid, Spain, 2022.
Abstract | Links | BibTeX | Tags: parallel
@inproceedings{GARCIA:PDP:22,
title = {Evaluating Micro-batch and Data Frequency for Stream Processing Applications on Multi-cores},
author = {Adriano Marques Garcia and Dalvan Griebler and Claudio Schepke and Luiz Gustavo Fernandes},
url = {https://iris.unito.it/retrieve/f6d113e5-789b-4f8b-924d-8ca3d38e8d62/PDP_2022__SPBench_with_Batch_and_Data_Frequency_.pdf},
doi = {10.1109/PDP55904.2022.00011},
year = {2022},
date = {2022-04-01},
booktitle = {30th Euromicro International Conference on Parallel, Distributed and Network-Based Processing (PDP)},
pages = {10-17},
publisher = {IEEE},
address = {Valladolid, Spain},
series = {PDP'22},
abstract = {In stream processing, data arrives constantly and is often unpredictable. It can show large fluctuations in arrival frequency, size, complexity, and other factors. These fluctuations can strongly impact application latency and throughput, which are critical factors in this domain. Therefore, there is a significant amount of research on self-adaptive techniques involving elasticity or micro-batching as a way to mitigate this impact. However, there is a lack of benchmarks and tools for helping researchers to investigate micro-batching and data stream frequency implications. In this paper, we extend a benchmarking framework to support dynamic micro-batching and data stream frequency management. We used it to create custom benchmarks and compare latency and throughput aspects from two different parallel libraries. We validate our solution through an extensive analysis of the impact of micro-batching and data stream frequency on stream processing applications using Intel TBB and FastFlow, which are two libraries that leverage stream parallelism on multi-core architectures. Our results demonstrated up to 33% throughput gain over latency using micro-batches. Additionally, while TBB ensures lower latency, FastFlow ensures higher throughput in the parallel applications for different data stream frequency configurations.},
keywords = {parallel},
pubstate = {published},
tppubtype = {inproceedings}
}
In stream processing, data arrives constantly and is often unpredictable. It can show large fluctuations in arrival frequency, size, complexity, and other factors. These fluctuations can strongly impact application latency and throughput, which are critical factors in this domain. Therefore, there is a significant amount of research on self-adaptive techniques involving elasticity or micro-batching as a way to mitigate this impact. However, there is a lack of benchmarks and tools for helping researchers to investigate micro-batching and data stream frequency implications. In this paper, we extend a benchmarking framework to support dynamic micro-batching and data stream frequency management. We used it to create custom benchmarks and compare latency and throughput aspects from two different parallel libraries. We validate our solution through an extensive analysis of the impact of micro-batching and data stream frequency on stream processing applications using Intel TBB and FastFlow, which are two libraries that leverage stream parallelism on multi-core architectures. Our results demonstrated up to 33% throughput gain over latency using micro-batches. Additionally, while TBB ensures lower latency, FastFlow ensures higher throughput in the parallel applications for different data stream frequency configurations.
Adriano Marques Garcia, Dalvan Griebler, Claudio Schepke, Luiz Gustavo Fernandes
SPBench: a framework for creating benchmarks of stream processing applications Journal Article
In: Computing, vol. 105, no. 5, pp. 1077-1099, 2022, ISBN: 1436-5057.
Abstract | Links | BibTeX | Tags: parallel
@article{GARCIA:Computing:22,
title = {SPBench: a framework for creating benchmarks of stream processing applications},
author = {Adriano Marques Garcia and Dalvan Griebler and Claudio Schepke and Luiz Gustavo Fernandes},
url = {https://iris.unito.it/retrieve/f17ea8c2-ddd8-425b-b4e7-8315218a6969/s00607-021-01025-6_preprint.pdf},
doi = {10.1007/s00607-021-01025-6},
isbn = {1436-5057},
year = {2022},
date = {2022-01-01},
journal = {Computing},
volume = {105},
number = {5},
pages = {1077-1099},
publisher = {Springer},
abstract = {In a fast-changing data-driven world, real-time data processing systems are becoming ubiquitous in everyday applications. The increasing data we produce, such as audio, video, image, and, text are demanding quickly and efficiently computation. Stream Parallelism allows accelerating this computation for real-time processing. But it is still a challenging task and most reserved for experts. In this paper, we present SPBench, a framework for benchmarking stream processing applications. It aims to support users with a set of real-world stream processing applications, which are made accessible through an Application Programming Interface (API) and executable via Command Line Interface (CLI) to create custom benchmarks. We tested SPBench by implementing parallel benchmarks with Intel Threading Building Blocks (TBB), FastFlow, and SPar. This evaluation provided useful insights and revealed the feasibility of the proposed framework in terms of usage, customization, and performance analysis. SPBench demonstrated to be a high-level, reusable, extensible, and easy of use abstraction to build parallel stream processing benchmarks on multi-core architectures.},
keywords = {parallel},
pubstate = {published},
tppubtype = {article}
}
In a fast-changing data-driven world, real-time data processing systems are becoming ubiquitous in everyday applications. The increasing data we produce, such as audio, video, image, and, text are demanding quickly and efficiently computation. Stream Parallelism allows accelerating this computation for real-time processing. But it is still a challenging task and most reserved for experts. In this paper, we present SPBench, a framework for benchmarking stream processing applications. It aims to support users with a set of real-world stream processing applications, which are made accessible through an Application Programming Interface (API) and executable via Command Line Interface (CLI) to create custom benchmarks. We tested SPBench by implementing parallel benchmarks with Intel Threading Building Blocks (TBB), FastFlow, and SPar. This evaluation provided useful insights and revealed the feasibility of the proposed framework in terms of usage, customization, and performance analysis. SPBench demonstrated to be a high-level, reusable, extensible, and easy of use abstraction to build parallel stream processing benchmarks on multi-core architectures.
2021
Adriano Marques Garcia, Dalvan Griebler, Claudio Schepke, Luiz Gustavo Fernandes
Introducing a Stream Processing Framework for Assessing Parallel Programming Interfaces Proceedings Article
In: 29th Euromicro International Conference on Parallel, Distributed and Network-Based Processing (PDP), pp. 84-88, IEEE, Valladolid, Spain, 2021.
Abstract | Links | BibTeX | Tags: parallel
@inproceedings{GARCIA:PDP:21,
title = {Introducing a Stream Processing Framework for Assessing Parallel Programming Interfaces},
author = {Adriano Marques Garcia and Dalvan Griebler and Claudio Schepke and Luiz Gustavo Fernandes},
url = {https://iris.unito.it/retrieve/8aa73a3f-0b1f-41e4-9440-a87bbaf6e9c4/PDP_2021__Stream_bench_Framework_.pdf},
doi = {10.1109/PDP52278.2021.00021},
year = {2021},
date = {2021-03-01},
booktitle = {29th Euromicro International Conference on Parallel, Distributed and Network-Based Processing (PDP)},
pages = {84-88},
publisher = {IEEE},
address = {Valladolid, Spain},
series = {PDP'21},
abstract = {Stream Processing applications are spread across different sectors of industry and people's daily lives. The increasing data we produce, such as audio, video, image, and text are demanding quickly and efficiently computation. It can be done through Stream Parallelism, which is still a challenging task and most reserved for experts. We introduce a Stream Processing framework for assessing Parallel Programming Interfaces (PPIs). Our framework targets multi-core architectures and C++ stream processing applications, providing an API that abstracts the details of the stream operators of these applications. Therefore, users can easily identify all the basic operators and implement parallelism through different PPIs. In this paper, we present the proposed framework, implement three applications using its API, and show how it works, by using it to parallelize and evaluate the applications with the PPIs Intel TBB, FastFlow, and SPar. The performance results were consistent with the literature.},
keywords = {parallel},
pubstate = {published},
tppubtype = {inproceedings}
}
Stream Processing applications are spread across different sectors of industry and people's daily lives. The increasing data we produce, such as audio, video, image, and text are demanding quickly and efficiently computation. It can be done through Stream Parallelism, which is still a challenging task and most reserved for experts. We introduce a Stream Processing framework for assessing Parallel Programming Interfaces (PPIs). Our framework targets multi-core architectures and C++ stream processing applications, providing an API that abstracts the details of the stream operators of these applications. Therefore, users can easily identify all the basic operators and implement parallelism through different PPIs. In this paper, we present the proposed framework, implement three applications using its API, and show how it works, by using it to parallelize and evaluate the applications with the PPIs Intel TBB, FastFlow, and SPar. The performance results were consistent with the literature.
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.
2020
Adriano Marques Garcia, Matheus Serpa, Dalvan Griebler, Claudio Schepke, Luiz Gustavo Fernandes, Philippe O. A. Navaux
The Impact of CPU Frequency Scaling on Power Consumption of Computing Infrastructures Proceedings Article
In: International Conference on Computational Science and its Applications (ICCSA), pp. 142-157, Springer, Cagliari, Italy, 2020.
Abstract | Links | BibTeX | Tags: parallel
@inproceedings{GARCIA:ICCSA:20,
title = {The Impact of CPU Frequency Scaling on Power Consumption of Computing Infrastructures},
author = {Adriano Marques Garcia and Matheus Serpa and Dalvan Griebler and Claudio Schepke and Luiz Gustavo Fernandes and Philippe O. A. Navaux},
url = {https://iris.unito.it/retrieve/3b8f3dc0-cd4d-4f36-801d-9e8c613ea2e8/ICCSA_Energy_governors_preprint.pdf},
doi = {10.1007/978-3-030-58817-5_12},
year = {2020},
date = {2020-07-01},
booktitle = {International Conference on Computational Science and its Applications (ICCSA)},
volume = {12254},
pages = {142-157},
publisher = {Springer},
address = {Cagliari, Italy},
series = {ICCSA'20},
abstract = {Since the demand for computing power increases, new architectures emerged to obtain better performance. Reducing the power and energy consumption of these architectures is one of the main challenges to achieving high-performance computing. Current research trends aim at developing new software and hardware techniques to achieve the best performance and energy trade-offs. In this work, we investigate the impact of different CPU frequency scaling techniques such as ondemand, performance, and powersave on the power and energy consumption of multi-core based computer infrastructure. We apply these techniques in PAMPAR, a parallel benchmark suite implemented in PThreads, OpenMP, MPI-1, and MPI-2 (spawn). We measure the energy and execution time of 10 benchmarks, varying the number of threads. Our results show that although powersave consumes up to 43.1% less power than performance and ondemand governors, it consumes the triple of energy due to the high execution time. Our experiments also show that the performance governor consumes up to 9.8% more energy than ondemand for CPU-bound benchmarks. Finally, our results show that PThreads has the lowest power consumption, consuming less than the sequential version for memory-bound benchmarks. Regarding performance, the performance governor achieved 3% of performance over the ondemand.},
keywords = {parallel},
pubstate = {published},
tppubtype = {inproceedings}
}
Since the demand for computing power increases, new architectures emerged to obtain better performance. Reducing the power and energy consumption of these architectures is one of the main challenges to achieving high-performance computing. Current research trends aim at developing new software and hardware techniques to achieve the best performance and energy trade-offs. In this work, we investigate the impact of different CPU frequency scaling techniques such as ondemand, performance, and powersave on the power and energy consumption of multi-core based computer infrastructure. We apply these techniques in PAMPAR, a parallel benchmark suite implemented in PThreads, OpenMP, MPI-1, and MPI-2 (spawn). We measure the energy and execution time of 10 benchmarks, varying the number of threads. Our results show that although powersave consumes up to 43.1% less power than performance and ondemand governors, it consumes the triple of energy due to the high execution time. Our experiments also show that the performance governor consumes up to 9.8% more energy than ondemand for CPU-bound benchmarks. Finally, our results show that PThreads has the lowest power consumption, consuming less than the sequential version for memory-bound benchmarks. Regarding performance, the performance governor achieved 3% of performance over the ondemand.
2019
Adriano Marques Garcia, Claudio Schepke, Alessandro Gonçalves Girardi
PAMPAR: A new parallel benchmark for performance and energy consumption evaluation Journal Article
In: Concurrency and Computation: Practice and Experience, vol. 32, no. 20, pp. 1-21, 2019.
Abstract | Links | BibTeX | Tags: parallel
@article{GARCIA:CCPE:19,
title = {PAMPAR: A new parallel benchmark for performance and energy consumption evaluation},
author = {Adriano Marques Garcia and Claudio Schepke and Alessandro Gonçalves Girardi},
url = {https://iris.unito.it/retrieve/d514c682-a567-4a02-93b7-9e27b6d3da03/Concurrency___Computation__Practice___Experience__Final_Version_.pdf},
doi = {10.1002/cpe.5504},
year = {2019},
date = {2019-10-01},
journal = {Concurrency and Computation: Practice and Experience},
volume = {32},
number = {20},
pages = {1-21},
abstract = {This paper presents PAMPAR, a new benchmark to evaluate the performance and energy consumption of different Parallel Programming Interfaces (PPIs). The benchmark is composed of 11 algorithms implemented in PThreads, OpenMP, MPI-1, and MPI-2 (spawn) PPIs. Previous studies have used some of these pseudo-applications to perform this type of evaluation in different architectures since there is no benchmark that offers this variety of PPIs and communication models. In this work, we measure the energy and performance of each pseudo-application in a single architecture, varying the number of threads/processes. We also organize the pseudo-applications according to their memory accesses, floating-point operations, and branches. The goal is to show that this set of pseudo-applications has enough features to build a parallel benchmark. The results show that there is no single best case that provides both better performance and low energy consumption in the presented scenarios. Moreover, the pseudo-applications usage of the system resources are different enough to represent different scenarios and be efficient as a benchmark.},
keywords = {parallel},
pubstate = {published},
tppubtype = {article}
}
This paper presents PAMPAR, a new benchmark to evaluate the performance and energy consumption of different Parallel Programming Interfaces (PPIs). The benchmark is composed of 11 algorithms implemented in PThreads, OpenMP, MPI-1, and MPI-2 (spawn) PPIs. Previous studies have used some of these pseudo-applications to perform this type of evaluation in different architectures since there is no benchmark that offers this variety of PPIs and communication models. In this work, we measure the energy and performance of each pseudo-application in a single architecture, varying the number of threads/processes. We also organize the pseudo-applications according to their memory accesses, floating-point operations, and branches. The goal is to show that this set of pseudo-applications has enough features to build a parallel benchmark. The results show that there is no single best case that provides both better performance and low energy consumption in the presented scenarios. Moreover, the pseudo-applications usage of the system resources are different enough to represent different scenarios and be efficient as a benchmark.
Adriano Marques Garcia, Claudio Schepke, Alessandro Gonçalves Girardi, Sherlon Almeida Silva
A New Parallel Benchmark for Performance Evaluation and Energy Consumption Proceedings Article
In: High Performance Computing for Computational Science – VECPAR 2018, pp. 188-201, Springer International Publishing, Cham, 2019, ISBN: 978-3-030-15996-2.
Abstract | Links | BibTeX | Tags: parallel
@inproceedings{GARCIA:VECPAR:19,
title = {A New Parallel Benchmark for Performance Evaluation and Energy Consumption},
author = {Adriano Marques Garcia and Claudio Schepke and Alessandro Gonçalves Girardi and Sherlon Almeida Silva},
url = {https://iris.unito.it/retrieve/1272dea3-b1ea-4356-af0d-d180cef341b9/VECPAR_2018_paper_preprint.pdf},
doi = {10.1007/978-3-030-15996-2_14},
isbn = {978-3-030-15996-2},
year = {2019},
date = {2019-03-01},
booktitle = {High Performance Computing for Computational Science – VECPAR 2018},
pages = {188-201},
publisher = {Springer International Publishing},
address = {Cham},
abstract = {This paper presents a new benchmark to evaluate performance and energy consumption of different Parallel Programming Interfaces (PPIs). The benchmark is composed of 11 algorithms implemented in PThreads, OpenMP, MPI-1 and MPI-2 (spawn) PPIs. Previous studies have used some of these applications to perform this type of evaluation in different architectures, since there is no benchmark that offers this variety of PPIs and communication models. In this work we measure the energy and performance of each application in a single architecture, varying the number of threads/processes. The goal is to show that this set of applications has enough features to form a parallel benchmark. The results show that there is no single best case that provides both better performance and low energy consumption in the presented scenarios. However, PThreads and OpenMP achieve the best trade-offs between performance and energy in most cases.},
keywords = {parallel},
pubstate = {published},
tppubtype = {inproceedings}
}
This paper presents a new benchmark to evaluate performance and energy consumption of different Parallel Programming Interfaces (PPIs). The benchmark is composed of 11 algorithms implemented in PThreads, OpenMP, MPI-1 and MPI-2 (spawn) PPIs. Previous studies have used some of these applications to perform this type of evaluation in different architectures, since there is no benchmark that offers this variety of PPIs and communication models. In this work we measure the energy and performance of each application in a single architecture, varying the number of threads/processes. The goal is to show that this set of applications has enough features to form a parallel benchmark. The results show that there is no single best case that provides both better performance and low energy consumption in the presented scenarios. However, PThreads and OpenMP achieve the best trade-offs between performance and energy in most cases.
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.
2018
Adriano Marques Garcia, Claudio Schepke, Alessandro Gonçalves Girardi, Sherlon Almeida Silva
Power Consumption of Parallel Programming Interfaces in Multicore Architectures: A Case Study Proceedings Article
In: 2018 Symposium on High Performance Computing Systems (WSCAD), pp. 77-83, 2018.
Abstract | Links | BibTeX | Tags: parallel
@inproceedings{GARCIA:WSCAD:18,
title = {Power Consumption of Parallel Programming Interfaces in Multicore Architectures: A Case Study},
author = {Adriano Marques Garcia and Claudio Schepke and Alessandro Gonçalves Girardi and Sherlon Almeida Silva},
url = {https://iris.unito.it/retrieve/cab823a1-a6f7-483f-929a-607a166e0e78/A_Case_Study___Adriano___IEEE.pdf},
doi = {10.1109/WSCAD.2018.00021},
year = {2018},
date = {2018-10-01},
booktitle = {2018 Symposium on High Performance Computing Systems (WSCAD)},
pages = {77-83},
abstract = {This paper presents a case study on the power consumption of different Parallel Programming Interfaces (PPIs) in multicore architectures. The study is based on the PAMPAR benchmark, which is composed of 11 algorithms implemented in PThreads, OpenMP, MPI-1 and MPI-2 (spawn) PPIs. The results show that there is no single best case that provides both better performance and low power consumption in the presented scenarios. However, PThreads and OpenMP achieve the best trade-offs between performance and power in most cases.},
keywords = {parallel},
pubstate = {published},
tppubtype = {inproceedings}
}
This paper presents a case study on the power consumption of different Parallel Programming Interfaces (PPIs) in multicore architectures. The study is based on the PAMPAR benchmark, which is composed of 11 algorithms implemented in PThreads, OpenMP, MPI-1 and MPI-2 (spawn) PPIs. The results show that there is no single best case that provides both better performance and low power consumption in the presented scenarios. However, PThreads and OpenMP achieve the best trade-offs between performance and power in most cases.
2011
C Grandi, B Bockelman, D Bonacorsi, I Fisk, Isidro González Caballero, Fabio Farina, M Hernández, Sanjay Padhi, Sabyasachi Sarkar, Andrea Sciabà, I Sfiligoi, F Spiga, M Úbeda García, D C Van Der Ster, Marian Zvada
CMS Distributed Computing Integration in the LHC sustained operations era Journal Article
In: vol. 331, pp. 062032, 2011.
@article{11:cms,
title = {CMS Distributed Computing Integration in the LHC sustained operations era},
author = {C Grandi and B Bockelman and D Bonacorsi and I Fisk and Isidro González Caballero and Fabio Farina and M Hernández and Sanjay Padhi and Sabyasachi Sarkar and Andrea Sciabà and I Sfiligoi and F Spiga and M Úbeda García and D C Van Der Ster and Marian Zvada},
year = {2011},
date = {2011-12-01},
booktitle = {Journal of Physics: Conference Series},
volume = {331},
pages = {062032},
keywords = {parallel},
pubstate = {published},
tppubtype = {article}
}
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.
Marco Aldinucci, Marco Danelutto, Jan Dünnweber
Optimization Techniques for Implementing Parallel Skeletons in Grid Environments Proceedings Article
In: Gorlatch, S. (Ed.): Proc. of CMPP: Intl. Workshop on Constructive Methods for Parallel Programming, pp. 35–47, Universität Münster, Germany, Stirling, Scotland, UK, 2004.
Abstract | Links | BibTeX | Tags: parallel
@inproceedings{lith_rmi:cmpp:04,
title = {Optimization Techniques for Implementing Parallel Skeletons in Grid Environments},
author = {Marco Aldinucci and Marco Danelutto and Jan Dünnweber},
editor = {S. Gorlatch},
url = {http://calvados.di.unipi.it/storage/paper_files/2004_RMI_cmpp.pdf},
year = {2004},
date = {2004-07-01},
booktitle = {Proc. of CMPP: Intl. Workshop on Constructive Methods for Parallel Programming},
pages = {35–47},
publisher = {Universität Münster, Germany},
address = {Stirling, Scotland, UK},
abstract = {Skeletons are common patterns of parallelism like, e.g., farm, pipeline that can be abstracted and offered to the application programmer as programming primitives. We describe the use and implementation of skeletons in a distributed grid environment, with the Java-based system Lithium as our reference implementation. Our main contribution are optimization techniques based on an asynchronous, optimized RMI interaction mechanism, which we integrated into the macro data flow (MDF) implementation technology of Lithium. We report initial experimental results that demonstrate the achieved improvements through the proposed optimizations on a simple grid testbed.},
keywords = {parallel},
pubstate = {published},
tppubtype = {inproceedings}
}
Skeletons are common patterns of parallelism like, e.g., farm, pipeline that can be abstracted and offered to the application programmer as programming primitives. We describe the use and implementation of skeletons in a distributed grid environment, with the Java-based system Lithium as our reference implementation. Our main contribution are optimization techniques based on an asynchronous, optimized RMI interaction mechanism, which we integrated into the macro data flow (MDF) implementation technology of Lithium. We report initial experimental results that demonstrate the achieved improvements through the proposed optimizations on a simple grid testbed.
Marco Aldinucci, Sonia Campa, Pierpaolo Ciullo, Massimo Coppola, Marco Danelutto, Paolo Pesciullesi, Roberto Ravazzolo, Massimo Torquati, Marco Vanneschi, Corrado Zoccolo
A framework for experimenting with structure parallel programming environment design Proceedings Article
In: Joubert, G. R., Nagel, W. E., Peters, F. J., Walter, W. V. (Ed.): Parallel Computing: Software Technology, Algorithms, Architectures and Applications (Proc. of PARCO 2003, Dresden, Germany), pp. 617–624, Elsevier, 2004, ISSN: 09275452.
Abstract | Links | BibTeX | Tags: parallel
@inproceedings{assist:parco:03,
title = {A framework for experimenting with structure parallel programming environment design},
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 = {G. R. Joubert and W. E. Nagel and F. J. Peters and W. V. Walter},
url = {http://calvados.di.unipi.it/storage/paper_files/2004_assist_parco03.pdf},
doi = {10.1016/S0927-5452(04)80077-7},
issn = {09275452},
year = {2004},
date = {2004-01-01},
booktitle = {Parallel Computing: Software Technology, Algorithms, Architectures and Applications (Proc. of PARCO 2003, Dresden, Germany)},
volume = {13},
pages = {617–624},
publisher = {Elsevier},
series = {Advances in Parallel Computing},
abstract = {ASSIST is a parallel programming environment aimed at providing programmers of complex parallel application with a suitable and effective programming tool. Being based on algoritmical skeletons and coordination languages technologies, the programming environment relieves the programmer from a number of cumbersome, error prone activities that are required when using traditional parallel programming environments. ASSIST has been specifically designed to be easily customizable in order to experiment different implementation techniques, solutions, algorithms or back-ends any time new features are required or new technologies become available. In this work we discuss how this goal has been achieved and how the current ASSIST programming environment has been already used to experiment solutions not implemented in the first version of the tool.},
keywords = {parallel},
pubstate = {published},
tppubtype = {inproceedings}
}
ASSIST is a parallel programming environment aimed at providing programmers of complex parallel application with a suitable and effective programming tool. Being based on algoritmical skeletons and coordination languages technologies, the programming environment relieves the programmer from a number of cumbersome, error prone activities that are required when using traditional parallel programming environments. ASSIST has been specifically designed to be easily customizable in order to experiment different implementation techniques, solutions, algorithms or back-ends any time new features are required or new technologies become available. In this work we discuss how this goal has been achieved and how the current ASSIST programming environment has been already used to experiment solutions not implemented in the first version of the tool.
Marco Aldinucci, Marco Danelutto
An operational semantics for skeletons Proceedings Article
In: Joubert, G. R., Nagel, W. E., Peters, F. J., Walter, W. V. (Ed.): Parallel Computing: Software Technology, Algorithms, Architectures and Applications (Proc. of PARCO 2003, Dresden, Germany), pp. 63–70, Elsevier, Germany, 2004.
Abstract | Links | BibTeX | Tags: parallel
@inproceedings{lith:sem:parco:03,
title = {An operational semantics for skeletons},
author = {Marco Aldinucci and Marco Danelutto},
editor = {G. R. Joubert and W. E. Nagel and F. J. Peters and W. V. Walter},
url = {http://calvados.di.unipi.it/storage/paper_files/2004_sem_parco03.pdf},
doi = {10.1016/S0927-5452(04)80011-X},
year = {2004},
date = {2004-01-01},
booktitle = {Parallel Computing: Software Technology, Algorithms, Architectures and Applications (Proc. of PARCO 2003, Dresden, Germany)},
volume = {13},
pages = {63–70},
publisher = {Elsevier},
address = {Germany},
series = {Advances in Parallel Computing},
abstract = {A major weakness of the current programming systems based on skeletons is that parallel semantics is usually provided in an informal way, thus preventing any formal comparison about program behavior. We describe a schema suitable for the description of both functional and parallel semantics of skeletal languages which is aimed at filling this gap. The proposed schema of semantics represents a handy framework to prove the correctness and validate different rewriting rules. These can be used to transform a skeleton program into a functionally equivalent but possibly faster version.},
keywords = {parallel},
pubstate = {published},
tppubtype = {inproceedings}
}
A major weakness of the current programming systems based on skeletons is that parallel semantics is usually provided in an informal way, thus preventing any formal comparison about program behavior. We describe a schema suitable for the description of both functional and parallel semantics of skeletal languages which is aimed at filling this gap. The proposed schema of semantics represents a handy framework to prove the correctness and validate different rewriting rules. These can be used to transform a skeleton program into a functionally equivalent but possibly faster version.
2003
Marco Aldinucci
Dynamic shared data in structured parallel programming frameworks PhD Thesis
Computer Science Dept., University of Pisa, 2003.
@phdthesis{phd:marco:2003,
title = {Dynamic shared data in structured parallel programming frameworks},
author = {Marco Aldinucci},
year = {2003},
date = {2003-12-01},
school = {Computer Science Dept., University of Pisa},
keywords = {parallel},
pubstate = {published},
tppubtype = {phdthesis}
}
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, Sonia Campa, Pierpaolo Ciullo, Massimo Coppola, Silvia Magini, Paolo Pesciullesi, Laura Potiti, Roberto Ravazzolo, Massimo Torquati, Marco Vanneschi, Corrado Zoccolo
The Implementation of ASSIST, an Environment for Parallel and Distributed Programming Proceedings Article
In: Kosch, H., Böszörményi, L., Hellwagner, H. (Ed.): Proc. of 9th Intl Euro-Par 2003 Parallel Processing, pp. 712–721, Springer, Klagenfurt, Austria, 2003, ISBN: 978-3-540-40788-1.
Abstract | Links | BibTeX | Tags: parallel
@inproceedings{assist:imp:europar:03,
title = {The Implementation of ASSIST, an Environment for Parallel and Distributed Programming},
author = {Marco Aldinucci and Sonia Campa and Pierpaolo Ciullo and Massimo Coppola and Silvia Magini and Paolo Pesciullesi and Laura Potiti 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_imp_europar.pdf},
doi = {10.1007/b12024},
isbn = {978-3-540-40788-1},
year = {2003},
date = {2003-08-01},
booktitle = {Proc. of 9th Intl Euro-Par 2003 Parallel Processing},
volume = {2790},
pages = {712–721},
publisher = {Springer},
address = {Klagenfurt, Austria},
series = {LNCS},
abstract = {We describe the implementation of ASSIST, a programming environment for parallel and distributed programs. Its coordination language is based of the parallel skeleton model, extended with new features to enhance expressiveness, parallel software reuse, software component integration and interfacing to external resources. The compilation process and the structure of the run-time support of ASSIST are discussed with respect to the issues introduced by the new characteristics, presenting an analysis of the first test results.},
keywords = {parallel},
pubstate = {published},
tppubtype = {inproceedings}
}
We describe the implementation of ASSIST, a programming environment for parallel and distributed programs. Its coordination language is based of the parallel skeleton model, extended with new features to enhance expressiveness, parallel software reuse, software component integration and interfacing to external resources. The compilation process and the structure of the run-time support of ASSIST are discussed with respect to the issues introduced by the new characteristics, presenting an analysis of the first test results.
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.
Marco Aldinucci
eskimo: experimenting skeletons on the shared address model Proceedings Article
In: Proc. of HLPP2003: Intl. Workshop on High-Level Parallel Programming, pp. 89–100, Paris, France, 2003.
Abstract | Links | BibTeX | Tags: parallel
@inproceedings{eskimo:hlpp:03,
title = {eskimo: experimenting skeletons on the shared address model},
author = {Marco Aldinucci},
url = {http://calvados.di.unipi.it/storage/paper_files/2003_eskimo_ppl.pdf},
year = {2003},
date = {2003-06-01},
booktitle = {Proc. of HLPP2003: Intl. Workshop on High-Level Parallel Programming},
pages = {89–100},
address = {Paris, France},
abstract = {We discuss the lack of expressivity in some skeleton-based parallel programming frameworks. 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 = {inproceedings}
}
We discuss the lack of expressivity in some skeleton-based parallel programming frameworks. 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.
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.