# Papers | Marco Aldinucci

### 2023

• Y. Arfat, G. Mittone, I. Colonnelli, F. D’Ascenzo, R. Esposito, and M. Aldinucci, “Pooling critical datasets with federated learning,” in Proc. of 31st euromicro intl. conference on parallel distributed and network-based processing (pdp), Napoli, Italy, 2023.

Federated Learning (FL) is becoming popular in different industrial sectors where data access is critical for security, privacy and the economic value of data itself. Unlike traditional machine learning, where all the data must be globally gathered for analysis, FL makes it possible to extract knowledge from data distributed across different organizations that can be coupled with different Machine Learning paradigms. In this work, we replicate, using Federated Learning, the analysis of a pooled dataset (with AdaBoost) that has been used to define the PRAISE score, which is today among the most accurate scores to evaluate the risk of a second acute myocardial infarction. We show that thanks to the extended-OpenFL framework, which implements AdaBoost.F, we can train a federated PRAISE model that exhibits comparable accuracy and recall as the centralised model. We achieved F1 and F2 scores which are consistently comparable to the PRAISE score study of a 16- parties federation but within an order of magnitude less time.

@inproceedings{23:praise-fl:pdp,
abstract = {Federated Learning (FL) is becoming popular in different industrial sectors where data access is critical for security, privacy and the economic value of data itself. Unlike traditional machine learning, where all the data must be globally gathered for analysis, FL makes it possible to extract knowledge from data distributed across different organizations that can be coupled with different Machine Learning paradigms. In this work, we replicate, using Federated Learning, the analysis of a pooled dataset (with AdaBoost) that has been used to define the PRAISE score, which is today among the most accurate scores to evaluate the risk of a second acute myocardial infarction. We show that thanks to the extended-OpenFL framework, which implements AdaBoost.F, we can train a federated PRAISE model that exhibits comparable accuracy and recall as the centralised model. We achieved F1 and F2 scores which are consistently comparable to the PRAISE score study of a 16- parties federation but within an order of magnitude less time.},
author = {Yasir Arfat and Gianluca Mittone and Iacopo Colonnelli and Fabrizio D'Ascenzo and Roberto Esposito and Marco Aldinucci},
booktitle = {Proc. of 31st Euromicro Intl. Conference on Parallel Distributed and network-based Processing (PDP)},
date-modified = {2023-02-04 18:34:25 +0100},
publisher = {IEEE},
title = {Pooling critical datasets with Federated Learning},
url = {https://iris.unito.it/retrieve/491e22ec-3db5-4989-a063-085a199edd20/23_pdp_fl.pdf},
year = {2023}
}

• S. G. Contaldo, L. Alessandri, I. Colonnelli, M. Beccuti, and M. Aldinucci, “Bringing cell subpopulation discovery on a cloud-HPC using rCASC and StreamFlow,” in Single cell transcriptomics: methods and protocols, R. A. Calogero and V. Benes, Eds., New York, NY: Springer US, 2023, p. 337–345. doi:10.1007/978-1-0716-2756-3_17

The idea behind novel single-cell RNA sequencing (scRNA-seq) pipelines is to isolate single cells through microfluidic approaches and generate sequencing libraries in which the transcripts are tagged to track their cell of origin. Modern scRNA-seq platforms are capable of analyzing up to many thousands of cells in each run. Then, combined with massive high-throughput sequencing producing billions of reads, scRNA-seq allows the assessment of fundamental biological properties of cell populations and biological systems at unprecedented resolution.

@inbook{Contaldo2023,
abstract = {The idea behind novel single-cell RNA sequencing (scRNA-seq) pipelines is to isolate single cells through microfluidic approaches and generate sequencing libraries in which the transcripts are tagged to track their cell of origin. Modern scRNA-seq platforms are capable of analyzing up to many thousands of cells in each run. Then, combined with massive high-throughput sequencing producing billions of reads, scRNA-seq allows the assessment of fundamental biological properties of cell populations and biological systems at unprecedented resolution.},
author = {Contaldo, Sandro Gepiro and Alessandri, Luca and Colonnelli, Iacopo and Beccuti, Marco and Aldinucci, Marco},
booktitle = {Single Cell Transcriptomics: Methods and Protocols},
doi = {10.1007/978-1-0716-2756-3_17},
isbn = {978-1-0716-2756-3},
pages = {337--345},
publisher = {Springer {US}},
title = {Bringing Cell Subpopulation Discovery on a Cloud-{HPC} Using {rCASC} and {StreamFlow}},
url = {https://doi.org/10.1007/978-1-0716-2756-3_17},
year = 2023,
bdsk-url-1 = {https://doi.org/10.1007/978-1-0716-2756-3_17}
}

### 2022

• M. Polato, R. Esposito, and M. Aldinucci, “Boosting the federation: cross-silo federated learning without gradient descent,” in Intl. Joint Conference on Neural Networks (ijcnn), {P}adua, {Italy}, 2022, pp. 1-10. doi:10.1109/IJCNN55064.2022.9892284

Federated Learning has been proposed to develop better AI systems without compromising the privacy of final users and the legitimate interests of private companies. Initially deployed by Google to predict text input on mobile devices, FL has been deployed in many other industries. Since its introduction, Federated Learning mainly exploited the inner working of neural networks and other gradient descent-based algorithms by either exchanging the weights of the model or the gradients computed during learning. While this approach has been very successful, it rules out applying FL in contexts where other models are preferred, e.g., easier to interpret or known to work better. This paper proposes FL algorithms that build federated models without relying on gradient descent-based methods. Specifically, we leverage distributed versions of the AdaBoost algorithm to acquire strong federated models. In contrast with previous approaches, our proposal does not put any constraint on the client-side learning models. We perform a large set of experiments on ten UCI datasets, comparing the algorithms in six non-iidness settings.

@inproceedings{22:fl:ijcnn,
abstract = {Federated Learning has been proposed to develop better AI systems without compromising the privacy of final users and the legitimate interests of private companies. Initially deployed by Google to predict text input on mobile devices, FL has been deployed in many other industries. Since its introduction, Federated Learning mainly exploited the inner working of neural networks and other gradient descent-based algorithms by either exchanging the weights of the model or the gradients computed during learning. While this approach has been very successful, it rules out applying FL in contexts where other models are preferred, e.g., easier to interpret or known to work better. This paper proposes FL algorithms that build federated models without relying on gradient descent-based methods. Specifically, we leverage distributed versions of the AdaBoost algorithm to acquire strong federated models. In contrast with previous approaches, our proposal does not put any constraint on the client-side learning models. We perform a large set of experiments on ten UCI datasets, comparing the algorithms in six non-iidness settings.},
author = {Mirko Polato and Roberto Esposito and Marco Aldinucci},
booktitle = {{I}ntl. {J}oint {C}onference on {N}eural {N}etworks (IJCNN)},
doi = {10.1109/IJCNN55064.2022.9892284},
keywords = {hpc4ai,eupilot},
month = {July},
pages = {1-10},
publisher = {{IEEE}},
title = {Boosting the Federation: Cross-Silo Federated Learning without Gradient Descent},
year = {2022},
bdsk-url-2 = {https://doi.org/10.1109/IJCNN55064.2022.9892284}
}

• E. Sulis, I. A. Amantea, M. Aldinucci, G. Boella, R. Marinello, M. Grosso, P. Platter, and S. Ambrosini, “An ambient assisted living architecture for hospital at home coupled with a process-oriented perspective,” Journal of ambient intelligence and humanized computing, 2022. doi:10.1007/s12652-022-04388-6

The growing number of next-generation applications offers a relevant opportunity for healthcare services, generating an urgent need for architectures for systems integration. Moreover, the huge amount of stored information related to events can be explored by adopting a process-oriented perspective. This paper discusses an Ambient Assisted Living healthcare architecture to manage hospital home-care services. The proposed solution relies on adopting an event manager to integrate sources ranging from personal devices to web-based applications. Data are processed on a federated cloud platform offering computing infrastructure and storage resources to improve scientific research. In a second step, a business process analysis of telehealth and telemedicine applications is considered. An initial study explored the business process flow to capture the main sequences of tasks, activities, events. This step paves the way for the integration of process mining techniques to compliance monitoring in an AAL architecture framework.

@article{Sulis2022,
abstract = {The growing number of next-generation applications offers a relevant opportunity for healthcare services, generating an urgent need for architectures for systems integration. Moreover, the huge amount of stored information related to events can be explored by adopting a process-oriented perspective. This paper discusses an Ambient Assisted Living healthcare architecture to manage hospital home-care services. The proposed solution relies on adopting an event manager to integrate sources ranging from personal devices to web-based applications. Data are processed on a federated cloud platform offering computing infrastructure and storage resources to improve scientific research. In a second step, a business process analysis of telehealth and telemedicine applications is considered. An initial study explored the business process flow to capture the main sequences of tasks, activities, events. This step paves the way for the integration of process mining techniques to compliance monitoring in an AAL architecture framework.},
author = {Sulis, Emilio and Amantea, Ilaria Angela and Aldinucci, Marco and Boella, Guido and Marinello, Renata and Grosso, Marco and Platter, Paolo and Ambrosini, Serena},
date = {2022/09/21},
date-modified = {2023-02-04 18:45:08 +0100},
doi = {10.1007/s12652-022-04388-6},
isbn = {1868-5145},
journal = {Journal of Ambient Intelligence and Humanized Computing},
title = {An ambient assisted living architecture for hospital at home coupled with a process-oriented perspective},
url = {https://iris.unito.it/retrieve/c7eaab0b-f78b-4af0-8c17-fa5479d776e6/jaihc2021-preprint.pdf},
year = {2022}
}

• F. Proietto Salanitri, G. Bellitto, S. Palazzo, I. Irmakci, M. B. Wallace, C. W. Bolan, M. Engels, S. Hoogenboom, M. Aldinucci, U. Bagci, D. Giordano, and C. Spampinato, “Neural transformers for intraductal papillary mucosal neoplasms (IPMN) classification in MRI images,” in 44th annual international conference of the IEEE engineering in medicine & biology society, EMBC 2022, glasgow, scotland, united kingdom, july 11-15, 2022, 2022, p. 475–479. doi:10.1109/EMBC48229.2022.9871547
@inproceedings{DBLP:conf/embc/SalanitriBPIWBE22,
author = {Proietto Salanitri, Federica and
Giovanni Bellitto and
Simone Palazzo and
Ismail Irmakci and
Wallace, Michael B. and
Bolan, Candice W. and
Megan Engels and
Sanne Hoogenboom and
Marco Aldinucci and
Ulas Bagci and
Daniela Giordano and
Concetto Spampinato},
title = {Neural Transformers for Intraductal Papillary Mucosal Neoplasms {(IPMN)}
Classification in {MRI} images},
booktitle = {44th Annual International Conference of the {IEEE} Engineering in
Medicine {\&} Biology Society, {EMBC} 2022, Glasgow, Scotland,
United Kingdom, July 11-15, 2022},
pages = {475--479},
publisher = {{IEEE}},
year = {2022},
keywords = {hpc4ai, canp},
url = {https://doi.org/10.1109/EMBC48229.2022.9871547},
doi = {10.1109/EMBC48229.2022.9871547}
}

• I. Colonnelli, B. Casella, G. Mittone, Y. Arfat, B. Cantalupo, R. Esposito, A. R. Martinelli, D. Medić, and M. Aldinucci, “Federated learning meets HPC and cloud,” in Astrophysics and space science proceedings, Catania, Italy, 2022.

HPC and AI are fated to meet for several reasons. This article will discuss some of them and argue why this will happen through the set of methods and technologies that underpin cloud computing. As a paradigmatic example, we present a new federated learning system that collaboratively trains a deep learning model in different supercomputing centers. The system is based on the StreamFlow workflow manager designed for hybrid cloud-HPC infrastructures.

@inproceedings{22:ml4astro,
abstract = {HPC and AI are fated to meet for several reasons. This article will discuss some of them and argue why this will happen through the set of methods and technologies that underpin cloud computing. As a paradigmatic example, we present a new federated learning system that collaboratively trains a deep learning model in different supercomputing centers. The system is based on the StreamFlow workflow manager designed for hybrid cloud-HPC infrastructures.},
author = {Iacopo Colonnelli and Bruno Casella and Gianluca Mittone and Yasir Arfat and Barbara Cantalupo and Roberto Esposito and Alberto Riccardo Martinelli and Doriana Medi\'{c} and Marco Aldinucci},
booktitle = {Astrophysics and Space Science Proceedings},
keywords = {across, eupilot, streamflow},
publisher = {Springer},
title = {Federated Learning meets {HPC} and cloud},
url = {https://iris.unito.it/retrieve/5631da1c-96a0-48c0-a48e-2cdf6b84841d/main.pdf},
year = {2022}
}

• V. Cesare, U. Becciani, A. Vecchiato, M. G. Lattanzi, F. Pitari, M. Raciti, G. Tudisco, M. Aldinucci, and B. Bucciarelli, “The gaia AVU-GSR parallel solver: preliminary studies of a LSQR-based application in perspective of exascale systems,” Astronomy and computing, p. 100660, 2022. doi:10.1016/j.ascom.2022.100660

The Gaia Astrometric Verification Unit–Global Sphere Reconstruction (AVU–GSR) Parallel Solver aims to find the astrometric parameters for circa 10^8 stars in the Milky Way, the attitude and the instrumental specifications of the Gaia satellite, and the global parameter γ of the post Newtonian formalism. The code iteratively solves a system of linear equations, A×x=b, where the coefficient matrix A is large (circa 10^11×10^8 elements) and sparse. To solve this system of equations, the code exploits a hybrid implementation of the iterative PC-LSQR algorithm, where the computation related to different horizontal portions of the coefficient matrix is assigned to separate MPI processes. In the original code, each matrix portion is further parallelized over the OpenMP threads. To further improve the code performance, we ported the application to the GPU, replacing the OpenMP parallelization language with OpenACC. In this port, ∼95\% of the data is copied from the host to the device at the beginning of the entire cycle of iterations, making the code compute bound rather than data-transfer bound. The OpenACC code presents a speedup of circa 1.5 over the OpenMP version but further optimizations are in progress to obtain higher gains. The code runs on multiple GPUs and it was tested on the CINECA supercomputer Marconi100, in anticipation of a port to the pre-exascale system Leonardo, that will be installed at CINECA in 2022.

@article{CESARE2022100660,
abstract = {The Gaia Astrometric Verification Unit--Global Sphere Reconstruction (AVU--GSR) Parallel Solver aims to find the astrometric parameters for circa 10^8 stars in the Milky Way, the attitude and the instrumental specifications of the Gaia satellite, and the global parameter γ of the post Newtonian formalism. The code iteratively solves a system of linear equations, A×x=b, where the coefficient matrix A is large (circa 10^11×10^8 elements) and sparse. To solve this system of equations, the code exploits a hybrid implementation of the iterative PC-LSQR algorithm, where the computation related to different horizontal portions of the coefficient matrix is assigned to separate MPI processes. In the original code, each matrix portion is further parallelized over the OpenMP threads. To further improve the code performance, we ported the application to the GPU, replacing the OpenMP parallelization language with OpenACC. In this port, ∼95\% of the data is copied from the host to the device at the beginning of the entire cycle of iterations, making the code compute bound rather than data-transfer bound. The OpenACC code presents a speedup of circa 1.5 over the OpenMP version but further optimizations are in progress to obtain higher gains. The code runs on multiple GPUs and it was tested on the CINECA supercomputer Marconi100, in anticipation of a port to the pre-exascale system Leonardo, that will be installed at CINECA in 2022.},
author = {Cesare, Valentina and Becciani, Ugo and Vecchiato, Alberto and Lattanzi, Mario Gilberto and Pitari, Fabio and Raciti, Mario and Tudisco, Giuseppe and Aldinucci, Marco and Bucciarelli, Beatrice},
doi = {10.1016/j.ascom.2022.100660},
issn = {2213-1337},
journal = {Astronomy and Computing},
keywords = {eupex},
pages = {100660},
title = {The Gaia {AVU-GSR} parallel solver: Preliminary studies of a {LSQR-based} application in perspective of exascale systems},
url = {https://openaccess.inaf.it/handle/20.500.12386/32451},
year = {2022},
bdsk-url-1 = {https://openaccess.inaf.it/handle/20.500.12386/32451},
bdsk-url-2 = {https://doi.org/10.1016/j.ascom.2022.100660}
}

• I. Colonnelli and M. Aldinucci, “Hybrid workflows for large – scale scientific applications,” in Sixth EAGE high performance computing workshop, Milano, Italy, 2022, p. 1–5. doi:10.3997/2214-4609.2022615029

Large-scale scientific applications are facing an irreversible transition from monolithic, high-performance oriented codes to modular and polyglot deployments of specialised (micro-)services. The reasons behind this transition are many: coupling of standard solvers with Deep Learning techniques, offloading of data analysis and visualisation to Cloud, and the advent of specialised hardware accelerators. Topology-aware Workflow Management Systems (WMSs) play a crucial role. In particular, topology-awareness allows an explicit mapping of workflow steps onto heterogeneous locations, allowing automated executions on top of hybrid architectures (e.g., cloud+HPC or classical+quantum). Plus, topology-aware WMSs can offer nonfunctional requirements OOTB, e.g. components’ life-cycle orchestration, secure and efficient data transfers, fault tolerance, and cross-cluster execution of urgent workloads. Augmenting interactive Jupyter Notebooks with distributed workflow capabilities allows domain experts to prototype and scale applications using the same technological stack, while relying on a feature-rich and user-friendly web interface. This abstract will showcase how these general methodologies can be applied to a typical geoscience simulation pipeline based on the Full Wavefront Inversion (FWI) technique. In particular, a prototypical Jupyter Notebook will be executed interactively on Cloud. Preliminary data analyses and post-processing will be executed locally, while the computationally demanding optimisation loop will be scheduled on a remote HPC cluster.

@inproceedings{22:eage-hpc-workshop,
author = {Iacopo Colonnelli and
Marco Aldinucci},
abstract = {Large-scale scientific applications are facing an irreversible transition from monolithic, high-performance oriented codes to modular and polyglot deployments of specialised (micro-)services. The reasons behind this transition are many: coupling of standard solvers with Deep Learning techniques, offloading of data analysis and visualisation to Cloud, and the advent of specialised hardware accelerators. Topology-aware Workflow Management Systems (WMSs) play a crucial role. In particular, topology-awareness allows an explicit mapping of workflow steps onto heterogeneous locations, allowing automated executions on top of hybrid architectures (e.g., cloud+HPC or classical+quantum). Plus, topology-aware WMSs can offer nonfunctional requirements OOTB, e.g. components’ life-cycle orchestration, secure and efficient data transfers, fault tolerance, and cross-cluster execution of urgent workloads. Augmenting interactive Jupyter Notebooks with distributed workflow capabilities allows domain experts to prototype and scale applications using the same technological stack, while relying on a feature-rich and user-friendly web interface. This abstract will showcase how these general methodologies can be applied to a typical geoscience simulation pipeline based on the Full Wavefront Inversion (FWI) technique. In particular, a prototypical Jupyter Notebook will be executed interactively on Cloud. Preliminary data analyses and post-processing will be executed locally, while the computationally demanding optimisation loop will be scheduled on a remote HPC cluster.},
title = {Hybrid Workflows For Large - Scale Scientific Applications},
booktitle = {Sixth {EAGE} High Performance Computing Workshop},
pages = {1--5},
publisher = {{European Association of Geoscientists \& Engineers }},
month = sep,
year = {2022},
issn = {2214-4609},
keywords = {across, eupex},
doi = {10.3997/2214-4609.2022615029},
url = {https://iris.unito.it/retrieve/d79ddabb-f9d7-4a55-9f84-1528b1533ba3/Extended_Abstract.pdf}
}

• G. Agosta, M. Aldinucci, C. Alvarez, R. Ammendola, Y. Arfat, O. Beaumont, M. Bernaschi, A. Biagioni, T. Boccali, B. Bramas, C. Brandolese, B. Cantalupo, M. Carrozzo, D. Cattaneo, A. Celestini, M. Celino, I. Colonnelli, P. Cretaro, P. D’Ambra, M. Danelutto, R. Esposito, L. Eyraud-Dubois, A. Filgueras, W. Fornaciari, O. Frezza, A. Galimberti, F. Giacomini, B. Goglin, D. Gregori, A. Guermouche, F. Iannone, M. Kulczewski, F. Lo Cicero, A. Lonardo, A. R. Martinelli, M. Martinelli, X. Martorell, G. Massari, S. Montangero, G. Mittone, R. Namyst, A. Oleksiak, P. Palazzari, P. S. Paolucci, F. Reghenzani, C. Rossi, S. Saponara, F. Simula, F. Terraneo, S. Thibault, M. Torquati, M. Turisini, P. Vicini, M. Vidal, D. Zoni, and G. Zummo, “Towards extreme scale technologies and accelerators for eurohpc hw/sw supercomputing applications for exascale: the textarossa approach,” Microprocessors and microsystems, vol. 95, p. 104679, 2022. doi:10.1016/j.micpro.2022.104679
[BibTeX] [Abstract]

In the near future, Exascale systems will need to bridge three technology gaps to achieve high performance while remaining under tight power constraints: energy efficiency and thermal control; extreme computation efficiency via HW acceleration and new arithmetic; methods and tools for seamless integration of reconfigurable accelerators in heterogeneous HPC multi-node platforms. TEXTAROSSA addresses these gaps through a co-design approach to heterogeneous HPC solutions, supported by the integration and extension of HW and SW IPs, programming models, and tools derived from European research.

@article{textarossa2022micpro:,
abstract = {In the near future, Exascale systems will need to bridge three technology gaps to achieve high performance while remaining under tight power constraints: energy efficiency and thermal control; extreme computation efficiency via HW acceleration and new arithmetic; methods and tools for seamless integration of reconfigurable accelerators in heterogeneous HPC multi-node platforms. TEXTAROSSA addresses these gaps through a co-design approach to heterogeneous HPC solutions, supported by the integration and extension of HW and SW IPs, programming models, and tools derived from European research.},
author = {Giovanni Agosta and Marco Aldinucci and Carlos Alvarez and Roberto Ammendola and Yasir Arfat and Olivier Beaumont and Massimo Bernaschi and Andrea Biagioni and Tommaso Boccali and Berenger Bramas and Carlo Brandolese and Barbara Cantalupo and Mauro Carrozzo and Daniele Cattaneo and Alessandro Celestini and Massimo Celino and Iacopo Colonnelli and Paolo Cretaro and Pasqua D'Ambra and Marco Danelutto and Roberto Esposito and Lionel Eyraud-Dubois and Antonio Filgueras and William Fornaciari and Ottorino Frezza and Andrea Galimberti and Francesco Giacomini and Brice Goglin and Daniele Gregori and Abdou Guermouche and Francesco Iannone and Michal Kulczewski and Francesca {Lo Cicero} and Alessandro Lonardo and Alberto R. Martinelli and Michele Martinelli and Xavier Martorell and Giuseppe Massari and Simone Montangero and Gianluca Mittone and Raymond Namyst and Ariel Oleksiak and Paolo Palazzari and Pier Stanislao Paolucci and Federico Reghenzani and Cristian Rossi and Sergio Saponara and Francesco Simula and Federico Terraneo and Samuel Thibault and Massimo Torquati and Matteo Turisini and Piero Vicini and Miquel Vidal and Davide Zoni and Giuseppe Zummo},
doi = {10.1016/j.micpro.2022.104679},
issn = {0141-9331},
journal = {Microprocessors and Microsystems},
keywords = {textrossa},
pages = {104679},
title = {Towards EXtreme scale technologies and accelerators for euROhpc hw/Sw supercomputing applications for exascale: The TEXTAROSSA approach},
volume = {95},
year = {2022},
bdsk-url-1 = {https://doi.org/10.1016/j.micpro.2022.104679}
}

• B. Casella, R. Esposito, C. Cavazzoni, and M. Aldinucci, “Benchmarking fedavg and fedcurv for image classification tasks,” in Proceedings of the 1st italian conference on big data and data science, ITADATA 2022, september 20-21, 2022, 2022.
@inproceedings{casella2022benchmarking,
author = {Bruno Casella and Roberto Esposito and Carlo Cavazzoni and Marco Aldinucci},
booktitle = {Proceedings of the 1st Italian Conference on Big Data and Data Science, {ITADATA} 2022, September 20-21, 2022},
editor = {Marco Anisetti and Angela Bonifati and Nicola Bena and Claudio Ardagna and Donato Malerba},
keywords = {eupilot},
publisher = {CEUR-WS.org},
series = {{CEUR} Workshop Proceedings},
title = {Benchmarking FedAvg and FedCurv for Image Classification Tasks},
year = {2022},
}

• M. Aldinucci, D. Atienza, F. Bolelli, M. Caballero, I. Colonnelli, J. Flich, J. A. Gómez, D. González, C. Grana, M. Grangetto, S. Leo, P. López, D. Oniga, R. Paredes, L. Pireddu, E. Quiñones, T. Silva, E. Tartaglione, and M. Zapater, “The DeepHealth toolkit: a key european free and open-source software for deep learning and computer vision ready to exploit heterogeneous HPC and Cloud architectures,” in Technologies and applications for big data value, E. Curry, S. Auer, A. J. Berre, A. Metzger, M. S. Perez, and S. Zillner, Eds., Cham: Springer international publishing, 2022, p. 183–202. doi:10.1007/978-3-030-78307-5_9

At the present time, we are immersed in the convergence between Big Data, High-Performance Computing and Artificial Intelligence. Technological progress in these three areas has accelerated in recent years, forcing different players like software companies and stakeholders to move quickly. The European Union is dedicating a lot of resources to maintain its relevant position in this scenario, funding projects to implement large-scale pilot testbeds that combine the latest advances in Artificial Intelligence, High-Performance Computing, Cloud and Big Data technologies. The DeepHealth project is an example focused on the health sector whose main outcome is the DeepHealth toolkit, a European unified framework that offers deep learning and computer vision capabilities, completely adapted to exploit underlying heterogeneous High-Performance Computing, Big Data and cloud architectures, and ready to be integrated into any software platform to facilitate the development and deployment of new applications for specific problems in any sector. This toolkit is intended to be one of the European contributions to the field of AI. This chapter introduces the toolkit with its main components and complementary tools, providing a clear view to facilitate and encourage its adoption and wide use by the European community of developers of AI-based solutions and data scientists working in the healthcare sector and others.

@incollection{22:TABDV,
abstract = {At the present time, we are immersed in the convergence between Big Data, High-Performance Computing and Artificial Intelligence. Technological progress in these three areas has accelerated in recent years, forcing different players like software companies and stakeholders to move quickly. The European Union is dedicating a lot of resources to maintain its relevant position in this scenario, funding projects to implement large-scale pilot testbeds that combine the latest advances in Artificial Intelligence, High-Performance Computing, Cloud and Big Data technologies. The DeepHealth project is an example focused on the health sector whose main outcome is the DeepHealth toolkit, a European unified framework that offers deep learning and computer vision capabilities, completely adapted to exploit underlying heterogeneous High-Performance Computing, Big Data and cloud architectures, and ready to be integrated into any software platform to facilitate the development and deployment of new applications for specific problems in any sector. This toolkit is intended to be one of the European contributions to the field of AI. This chapter introduces the toolkit with its main components and complementary tools, providing a clear view to facilitate and encourage its adoption and wide use by the European community of developers of AI-based solutions and data scientists working in the healthcare sector and others.},
author = {Marco Aldinucci and David Atienza and Federico Bolelli and M\'{o}nica Caballero and Iacopo Colonnelli and Jos\'{e} Flich and Jon Ander G\'{o}mez and David Gonz\'{a}lez and Costantino Grana and Marco Grangetto and Simone Leo and Pedro L\'{o}pez and Dana Oniga and Roberto Paredes and Luca Pireddu and Eduardo Qui\~{n}ones and Tatiana Silva and Enzo Tartaglione and Marina Zapater},
booktitle = {Technologies and Applications for Big Data Value},
chapter = {9},
doi = {10.1007/978-3-030-78307-5_9},
editor = {Edward Curry and S\"{o}ren Auer and Arne J. Berre and Andreas Metzger and Maria S. Perez and Sonja Zillner},
isbn = {978-3-030-78307-5},
keywords = {deephealth, streamflow},
pages = {183--202},
publisher = {Springer International Publishing},
title = {The {DeepHealth} Toolkit: A Key European Free and Open-Source Software for Deep Learning and Computer Vision Ready to Exploit Heterogeneous {HPC} and {C}loud Architectures},
year = {2022},
bdsk-url-2 = {https://doi.org/10.1007/978-3-030-78307-5_9}
}

• E. Quiñones, J. Perales, J. Ejarque, A. Badouh, S. Marco, F. Auzanneau, F. Galea, D. González, J. R. Hervás, T. Silva, I. Colonnelli, B. Cantalupo, M. Aldinucci, E. Tartaglione, R. Tornero, J. Flich, J. M. Martinez, D. Rodriguez, I. Catalán, J. Garcia, and C. Hernández, “The DeepHealth HPC infrastructure: leveraging heterogenous HPC and cloud computing infrastructures for IA-based medical solutions,” in HPC, big data, and AI convergence towards exascale: challenge and vision, O. Terzo and J. Martinovič, Eds., Boca Raton, Florida: CRC press, 2022, p. 191–216. doi:10.1201/9781003176664

This chapter presents the DeepHealth HPC toolkit for an efficient execution of deep learning (DL) medical application into HPC and cloud-computing infrastructures, featuring many-core, GPU, and FPGA acceleration devices. The toolkit offers to the European Computer Vision Library and the European Distributed Deep Learning Library (EDDL), developed in the DeepHealth project as well, the mechanisms to distribute and parallelize DL operations on HPC and cloud infrastructures in a fully transparent way. The toolkit implements workflow managers used to orchestrate HPC workloads for an efficient parallelization of EDDL training operations on HPC and cloud infrastructures, and includes the parallel programming models for an efficient execution EDDL inference and training operations on many-core, GPUs and FPGAs acceleration devices.

@incollection{22:deephealth:HPCbook,
abstract = {This chapter presents the DeepHealth HPC toolkit for an efficient execution of deep learning (DL) medical application into HPC and cloud-computing infrastructures, featuring many-core, GPU, and FPGA acceleration devices. The toolkit offers to the European Computer Vision Library and the European Distributed Deep Learning Library (EDDL), developed in the DeepHealth project as well, the mechanisms to distribute and parallelize DL operations on HPC and cloud infrastructures in a fully transparent way. The toolkit implements workflow managers used to orchestrate HPC workloads for an efficient parallelization of EDDL training operations on HPC and cloud infrastructures, and includes the parallel programming models for an efficient execution EDDL inference and training operations on many-core, GPUs and FPGAs acceleration devices.},
author = {Eduardo Qui\~{n}ones and Jesus Perales and Jorge Ejarque and Asaf Badouh and Santiago Marco and Fabrice Auzanneau and Fran\c{c}ois Galea and David Gonz\'{a}lez and Jos\'{e} Ram\'{o}n Herv\'{a}s and Tatiana Silva and Iacopo Colonnelli and Barbara Cantalupo and Marco Aldinucci and Enzo Tartaglione and Rafael Tornero and Jos\'{e} Flich and Jose Maria Martinez and David Rodriguez and Izan Catal\'{a}n and Jorge Garcia and Carles Hern\'{a}ndez},
booktitle = {{HPC}, Big Data, and {AI} Convergence Towards Exascale: Challenge and Vision},
chapter = {10},
doi = {10.1201/9781003176664},
editor = {Olivier Terzo and Jan Martinovi\v{c}},
isbn = {978-1-0320-0984-1},
keywords = {deephealth, streamflow},
pages = {191--216},
publisher = {{CRC} Press},
title = {The {DeepHealth} {HPC} Infrastructure: Leveraging Heterogenous {HPC} and Cloud Computing Infrastructures for {IA}-based Medical Solutions},
url = {https://iris.unito.it/retrieve/handle/2318/1832050/912413/Preprint.pdf},
year = {2022},
bdsk-url-1 = {https://iris.unito.it/retrieve/handle/2318/1832050/912413/Preprint.pdf},
bdsk-url-2 = {https://doi.org/10.1201/9781003176664}
}

• M. Golasowski, J. Martinovič, M. Levrier, S. Hachinger, S. Karagiorgou, A. Papapostolou, S. Mouzakitis, I. Tsapelas, M. Caballero, M. Aldinucci, J. A. Gómez, A. Chazapis, and J. Acquaviva, “Toward the convergence of high-performance computing, cloud, and big data domains,” in HPC, big data, and AI convergence towards exascale: challenge and vision, O. Terzo and J. Martinovič, Eds., Boca Raton, Florida: CRC press, 2022, p. 1–16. doi:10.1201/9781003176664
[BibTeX] [Abstract]

Convergence between big data, high-performance computing, and the cloud is the key driving factor for sustainable economic growth in the future. Technological advances in many fields are determined by competence to gain precise information from the large amounts of data collected, which in turn requires powerful computing resources. This chapter provides an overview on the evolution of the three fields and four different points of view on their convergence provided by the CYBELE, DeepHealth, Evolve, and LEXIS projects funded by the European Union under the Horizon 2020 Programme.

@incollection{22:intro:HPCbook,
abstract = {Convergence between big data, high-performance computing, and the cloud is the key driving factor for sustainable economic growth in the future. Technological advances in many fields are determined by competence to gain precise information from the large amounts of data collected, which in turn requires powerful computing resources. This chapter provides an overview on the evolution of the three fields and four different points of view on their convergence provided by the CYBELE, DeepHealth, Evolve, and LEXIS projects funded by the European Union under the Horizon 2020 Programme.},
author = {Martin Golasowski and Jan Martinovi{\v c} and Marc Levrier and Stephan Hachinger and Sophia Karagiorgou and Aikaterini Papapostolou and Spiros Mouzakitis and Ioannis Tsapelas and Monica Caballero and Marco Aldinucci and Jon Ander G{\'o}mez and Antony Chazapis and Jean-Thomas Acquaviva},
booktitle = {{HPC}, Big Data, and {AI} Convergence Towards Exascale: Challenge and Vision},
chapter = {1},
doi = {10.1201/9781003176664},
editor = {Olivier Terzo and Jan Martinovi\v{c}},
isbn = {978-1-0320-0984-1},
keywords = {deephealth, streamflow},
pages = {1--16},
publisher = {{CRC} Press},
title = {Toward the Convergence of High-Performance Computing, Cloud, and Big Data Domains},
year = {2022},
bdsk-url-1 = {https://doi.org/10.1201/9781003176664}
}

• D. Oniga, B. Cantalupo, E. Tartaglione, D. Perlo, M. Grangetto, M. Aldinucci, F. Bolelli, F. Pollastri, M. Cancilla, L. Canalini, C. Grana, C. M. Alcalde, F. A. Cardillo, and M. Florea, “Applications of AI and HPC in the health domain,” in HPC, big data, and AI convergence towards exascale: challenge and vision, O. Terzo and J. Martinovič, Eds., Boca Raton, Florida: CRC press, 2022, p. 217–239. doi:10.1201/9781003176664
[BibTeX] [Abstract]

This chapter presents the applications of artificial intelligence (AI) and high-computing performance (HPC) in the health domain, illustrated by the description of five of the use cases that are developed in the DeepHealth project. In the context of the European Commission supporting the use of AI and HPC in the health sector, DeepHealth Project is helping health experts process large quantities of images, putting at their disposal DeepLearning and computer vision techniques, combined in the DeepHealth toolkit and HPC infrastructures. The DeepHealth toolkit is tested and validated through 15 use cases, each of them representing a biomedical application. The most promising use cases are described in the chapter, which concludes with the value proposition and the benefits that DeepHealth toolkit offers to future end users.

@incollection{22:applications:HPCbook,
abstract = {This chapter presents the applications of artificial intelligence (AI) and high-computing performance (HPC) in the health domain, illustrated by the description of five of the use cases that are developed in the DeepHealth project. In the context of the European Commission supporting the use of AI and HPC in the health sector, DeepHealth Project is helping health experts process large quantities of images, putting at their disposal DeepLearning and computer vision techniques, combined in the DeepHealth toolkit and HPC infrastructures. The DeepHealth toolkit is tested and validated through 15 use cases, each of them representing a biomedical application. The most promising use cases are described in the chapter, which concludes with the value proposition and the benefits that DeepHealth toolkit offers to future end users.},
author = {Dana Oniga and Barbara Cantalupo and Enzo Tartaglione and Daniele Perlo and Marco Grangetto and Marco Aldinucci and Federico Bolelli and Federico Pollastri and Michele Cancilla and Laura Canalini and Costantino Grana and Cristina Mu{\~n}oz Alcalde and Franco Alberto Cardillo and Monica Florea},
booktitle = {{HPC}, Big Data, and {AI} Convergence Towards Exascale: Challenge and Vision},
chapter = {11},
doi = {10.1201/9781003176664},
editor = {Olivier Terzo and Jan Martinovi\v{c}},
isbn = {978-1-0320-0984-1},
keywords = {deephealth, streamflow},
pages = {217--239},
publisher = {{CRC} Press},
title = {Applications of {AI} and {HPC} in the Health Domain},
year = {2022},
bdsk-url-1 = {https://doi.org/10.1201/9781003176664}
}

• I. Colonnelli, M. Aldinucci, B. Cantalupo, L. Padovani, S. Rabellino, C. Spampinato, R. Morelli, R. Di Carlo, N. Magini, and C. Cavazzoni, “Distributed workflows with Jupyter,” Future generation computer systems, vol. 128, pp. 282-298, 2022. doi:10.1016/j.future.2021.10.007

The designers of a new coordination interface enacting complex workflows have to tackle a dichotomy: choosing a language-independent or language-dependent approach. Language-independent approaches decouple workflow models from the host code’s business logic and advocate portability. Language-dependent approaches foster flexibility and performance by adopting the same host language for business and coordination code. Jupyter Notebooks, with their capability to describe both imperative and declarative code in a unique format, allow taking the best of the two approaches, maintaining a clear separation between application and coordination layers but still providing a unified interface to both aspects. We advocate the Jupyter Notebooks’ potential to express complex distributed workflows, identifying the general requirements for a Jupyter-based Workflow Management System (WMS) and introducing a proof-of-concept portable implementation working on hybrid Cloud-HPC infrastructures. As a byproduct, we extended the vanilla IPython kernel with workflow-based parallel and distributed execution capabilities. The proposed Jupyter-workflow (Jw) system is evaluated on common scenarios for High Performance Computing (HPC) and Cloud, showing its potential in lowering the barriers between prototypical Notebooks and production-ready implementations.

@article{21:FGCS:jupyflow,
abstract = {The designers of a new coordination interface enacting complex workflows have to tackle a dichotomy: choosing a language-independent or language-dependent approach. Language-independent approaches decouple workflow models from the host code's business logic and advocate portability. Language-dependent approaches foster flexibility and performance by adopting the same host language for business and coordination code. Jupyter Notebooks, with their capability to describe both imperative and declarative code in a unique format, allow taking the best of the two approaches, maintaining a clear separation between application and coordination layers but still providing a unified interface to both aspects. We advocate the Jupyter Notebooks' potential to express complex distributed workflows, identifying the general requirements for a Jupyter-based Workflow Management System (WMS) and introducing a proof-of-concept portable implementation working on hybrid Cloud-HPC infrastructures. As a byproduct, we extended the vanilla IPython kernel with workflow-based parallel and distributed execution capabilities. The proposed Jupyter-workflow (Jw) system is evaluated on common scenarios for High Performance Computing (HPC) and Cloud, showing its potential in lowering the barriers between prototypical Notebooks and production-ready implementations.},
author = {Iacopo Colonnelli and Marco Aldinucci and Barbara Cantalupo and Luca Padovani and Sergio Rabellino and Concetto Spampinato and Roberto Morelli and Rosario {Di Carlo} and Nicol{\o} Magini and Carlo Cavazzoni},
doi = {10.1016/j.future.2021.10.007},
issn = {0167-739X},
journal = {Future Generation Computer Systems},
keywords = {streamflow, jupyter-workflow},
pages = {282-298},
title = {Distributed workflows with {Jupyter}},
url = {https://www.sciencedirect.com/science/article/pii/S0167739X21003976},
volume = {128},
year = {2022},
bdsk-url-1 = {https://www.sciencedirect.com/science/article/pii/S0167739X21003976},
bdsk-url-2 = {https://doi.org/10.1016/j.future.2021.10.007}
}

### 2021

• C. Pino, S. Palazzo, F. Trenta, F. Cordero, U. Bagci, F. Rundo, S. Battiato, D. Giordano, M. Aldinucci, and C. Spampinato, “Interpretable deep model for predicting gene-addicted non-small-cell lung cancer in CT scans,” in 18th IEEE intl. symposium on biomedical imaging (ISBI), Nice, France, 2021. doi:10.1109/ISBI48211.2021.9433832

Genetic profiling and characterization of lung cancers have recently emerged as a new technique for targeted therapeutic treatment based on immunotherapy or molecular drugs. However, the most effective way to discover specific gene mutations through tissue biopsy has several limitations, from invasiveness to being a risky procedure. Recently, quantitative assessment of visual features from CT data has been demonstrated to be a valid alternative to biopsy for the diagnosis of gene-addicted tumors. In this paper, we present a deep model for automated lesion segmentation and classification as gene-addicted or not. The segmentation approach extends the 2D Tiramisu architecture for 3D segmentation through dense blocks and squeeze-and-excitation layers, while a multi-scale 3D CNN is used for lesion classification. We also train our model with adversarial samples, and show that this approach acts as a gradient regularizer and enhances model interpretability. We also built a dataset, the first of its nature, consisting of 73 CT scans annotated with the presence of a specific genomics profile. We test our approach on this dataset achieving a segmentation accuracy of 93.11\% (Dice score) and a classification accuracy in identifying oncogene-addicted lung tumors of 82.00\%.

@inproceedings{21:ct:isbi,
abstract = {Genetic profiling and characterization of lung cancers have recently emerged as a new technique for targeted therapeutic treatment based on immunotherapy or molecular drugs. However, the most effective way to discover specific gene mutations through tissue biopsy has several limitations, from invasiveness to being a risky procedure. Recently, quantitative assessment of visual features from CT data has been demonstrated to be a valid alternative to biopsy for the diagnosis of gene-addicted tumors. In this paper, we present a deep model for automated lesion segmentation and classification as gene-addicted or not. The segmentation approach extends the 2D Tiramisu architecture for 3D segmentation through dense blocks and squeeze-and-excitation layers, while a multi-scale 3D CNN is used for lesion classification. We also train our model with adversarial samples, and show that this approach acts as a gradient regularizer and enhances model interpretability. We also built a dataset, the first of its nature, consisting of 73 CT scans annotated with the presence of a specific genomics profile. We test our approach on this dataset achieving a segmentation accuracy of 93.11\% (Dice score) and a classification accuracy in identifying oncogene-addicted lung tumors of 82.00\%.},
author = {Carmelo Pino and Simone Palazzo and Francesca Trenta and Francesca Cordero and Ulas Bagci and Francesco Rundo and Sebastiano Battiato and Daniela Giordano and Marco Aldinucci and Concetto Spampinato},
booktitle = {18th {IEEE} Intl. Symposium on Biomedical Imaging {(ISBI)}},
doi = {10.1109/ISBI48211.2021.9433832},
keywords = {deephealth},
month = apr,
publisher = {IEEE},
title = {Interpretable Deep Model for Predicting Gene-Addicted Non-Small-Cell Lung Cancer in {CT} Scans},
url = {https://iris.unito.it/retrieve/handle/2318/1790376/764762/21_ISBI_smallcell.pdf},
year = {2021},
bdsk-url-1 = {https://iris.unito.it/retrieve/handle/2318/1790376/764762/21_ISBI_smallcell.pdf},
bdsk-url-2 = {https://doi.org/10.1109/ISBI48211.2021.9433832}
}

• C. Pino, G. Vecchio, M. Fronda, M. Calandri, M. Aldinucci, and C. Spampinato, “Twinlivernet: predicting TACE treatment outcome from CT scans for hepatocellular carcinoma using deep capsule networks,” in 43rd annual international conference of the IEEE engineering in medicine & biology society, EMBC 2021, mexico, november 1-5, 2021, 2021, p. 3039–3043. doi:10.1109/EMBC46164.2021.9630913

Predicting response to treatment plays a key role to assist radiologists in hepato-cellular carcinoma (HCC) therapy planning. The most widely used treatment for unresectable HCC is the trans-arterial chemoembolization (TACE). A complete radiological response after the first TACE is a reliable predictor of treatment favourable outcome. However, visual inspection of contrast-enhanced CT scans is time-consuming, error prone and too operator-dependent. Thus, in this paper we propose TwinLiverNet: a deep neural network that is able to predict TACE treatment outcome through learning visual cue from CT scans. TwinLiverNet, specifically, integrates 3D convolutions and capsule networks and is designed to process simultaneously late arterial and delayed phases from contrast-enhanced CTs. Experimental results carried out on a dataset consisting of 126 HCC lesions show that TwinLiverNet reaches an average accuracy of 82\% in predicting complete response to TACE treatment. Furthermore, combining multiple CT phases (specifically, late arterial and delayed ones) yields a performance increase of over 12 percent points. Finally, the introduction of capsule layers into the model avoids the model to overfit, while enhancing accuracy.Clinical relevance–- TwinLiverNet supports radiologists in visual inspection of CT scans to assess TACE treatment outcome, while reducing inter-operator variability.

@inproceedings{21:DBLP:conf/embc/PinoVFCAS21,
abstract = {Predicting response to treatment plays a key role to assist radiologists in hepato-cellular carcinoma (HCC) therapy planning. The most widely used treatment for unresectable HCC is the trans-arterial chemoembolization (TACE). A complete radiological response after the first TACE is a reliable predictor of treatment favourable outcome. However, visual inspection of contrast-enhanced CT scans is time-consuming, error prone and too operator-dependent. Thus, in this paper we propose TwinLiverNet: a deep neural network that is able to predict TACE treatment outcome through learning visual cue from CT scans. TwinLiverNet, specifically, integrates 3D convolutions and capsule networks and is designed to process simultaneously late arterial and delayed phases from contrast-enhanced CTs. Experimental results carried out on a dataset consisting of 126 HCC lesions show that TwinLiverNet reaches an average accuracy of 82\% in predicting complete response to TACE treatment. Furthermore, combining multiple CT phases (specifically, late arterial and delayed ones) yields a performance increase of over 12 percent points. Finally, the introduction of capsule layers into the model avoids the model to overfit, while enhancing accuracy.Clinical relevance--- TwinLiverNet supports radiologists in visual inspection of CT scans to assess TACE treatment outcome, while reducing inter-operator variability.},
author = {C. Pino and G. Vecchio and Marco Fronda and Marco Calandri and Marco Aldinucci and Concetto Spampinato},
bibsource = {dblp computer science bibliography, https://dblp.org},
biburl = {https://dblp.org/rec/conf/embc/PinoVFCAS21.bib},
booktitle = {43rd Annual International Conference of the {IEEE} Engineering in Medicine {\&} Biology Society, {EMBC} 2021, Mexico, November 1-5, 2021},
doi = {10.1109/EMBC46164.2021.9630913},
pages = {3039--3043},
publisher = {{IEEE}},
timestamp = {Thu, 06 Jan 2022 07:54:56 +0100},
title = {TwinLiverNet: Predicting {TACE} Treatment Outcome from {CT} scans for Hepatocellular Carcinoma using Deep Capsule Networks},
url = {https://doi.org/10.1109/EMBC46164.2021.9630913},
year = {2021},
bdsk-url-1 = {https://doi.org/10.1109/EMBC46164.2021.9630913}
}

• G. Bontempi, R. Chavarriaga, H. De Canck, E. Girardi, H. Hoos, I. Kilbane‐Dawe, T. Ball, A. Nowé, J. Sousa, D. Bacciu, M. Aldinucci, M. De Domenico, A. Saffiotti, and M. Maratea, “The CLAIRE COVID-19 initiative: approach, experiences and recommendations,” Ethics and information technology, 2021. doi:10.1007/s10676-020-09567-7

A volunteer effort by Artificial Intelligence (AI) researchers has shown it can deliver significant research outcomes rapidly to help tackle COVID-19. Within two months, CLAIRE’s self-organising volunteers delivered the World’s first comprehensive curated repository of COVID-19-related datasets useful for drug-repurposing, drafted review papers on the role CT/X-ray scan analysis and robotics could play, and progressed research in other areas. Given the pace required and nature of voluntary efforts, the teams faced a number of challenges. These offer insights in how better to prepare for future volunteer scientific efforts and large scale, data-dependent AI collaborations in general. We offer seven recommendations on how to best leverage such efforts and collaborations in the context of managing future crises.

@article{21:eit:covidclaire,
abstract = {A volunteer effort by Artificial Intelligence (AI) researchers has shown it can deliver significant research outcomes rapidly to help tackle COVID-19. Within two months, CLAIRE's self-organising volunteers delivered the World's first comprehensive curated repository of COVID-19-related datasets useful for drug-repurposing, drafted review papers on the role CT/X-ray scan analysis and robotics could play, and progressed research in other areas. Given the pace required and nature of voluntary efforts, the teams faced a number of challenges. These offer insights in how better to prepare for future volunteer scientific efforts and large scale, data-dependent AI collaborations in general. We offer seven recommendations on how to best leverage such efforts and collaborations in the context of managing future crises.},
author = {Bontempi, Gianluca and Chavarriaga, Ricardo and De Canck, Hans and Girardi, Emanuela and Hoos, Holger and Kilbane‐Dawe, Iarla and Ball, Tonio and Now{\'e}, Ann and Sousa, Jose and Bacciu, Davide and Aldinucci, Marco and De Domenico, Manlio and Saffiotti, Alessandro and Maratea, Marco},
date-modified = {2021-08-29 16:12:25 +0200},
doi = {10.1007/s10676-020-09567-7},
journal = {Ethics and Information Technology},
keywords = {claire, deephealth},
month = feb,
publisher = {Springer},
title = {The {CLAIRE COVID-19} initiative: approach, experiences and recommendations},
url = {https://iris.unito.it/retrieve/handle/2318/1784271/747923/Bontempi2021_Article_TheCLAIRECOVID-19InitiativeApp-3.pdf},
year = {2021},
bdsk-url-1 = {https://iris.unito.it/retrieve/handle/2318/1784271/747923/Bontempi2021_Article_TheCLAIRECOVID-19InitiativeApp-3.pdf},
bdsk-url-2 = {https://doi.org/10.1007/s10676-020-09567-7}
}

• I. Colonnelli, B. Cantalupo, I. Merelli, and M. Aldinucci, “StreamFlow: cross-breeding cloud with HPC,” IEEE Transactions on Emerging Topics in Computing, vol. 9, iss. 4, p. 1723–1737, 2021. doi:10.1109/TETC.2020.3019202

Workflows are among the most commonly used tools in a variety of execution environments. Many of them target a specific environment; few of them make it possible to execute an entire workflow in different environments, e.g. Kubernetes and batch clusters. We present a novel approach to workflow execution, called StreamFlow, that complements the workflow graph with the declarative description of potentially complex execution environments, and that makes it possible the execution onto multiple sites not sharing a common data space. StreamFlow is then exemplified on a novel bioinformatics pipeline for single cell transcriptomic data analysis workflow.

@article{20Lstreamflow:tetc,
abstract = {Workflows are among the most commonly used tools in a variety of execution environments. Many of them target a specific environment; few of them make it possible to execute an entire workflow in different environments, e.g. Kubernetes and batch clusters. We present a novel approach to workflow execution, called StreamFlow, that complements the workflow graph with the declarative description of potentially complex execution environments, and that makes it possible the execution onto multiple sites not sharing a common data space. StreamFlow is then exemplified on a novel bioinformatics pipeline for single cell transcriptomic data analysis workflow.},
author = {Iacopo Colonnelli and Barbara Cantalupo and Ivan Merelli and Marco Aldinucci},
date-modified = {2020-08-27 09:36:33 +0200},
doi = {10.1109/TETC.2020.3019202},
journal = {{IEEE} {T}ransactions on {E}merging {T}opics in {C}omputing},
keywords = {deephealth, hpc4ai, streamflow},
number = {4},
pages = {1723--1737},
title = {{StreamFlow}: cross-breeding cloud with {HPC}},
url = {https://arxiv.org/pdf/2002.01558},
volume = {9},
year = {2021},
bdsk-url-1 = {https://arxiv.org/pdf/2002.01558},
bdsk-url-2 = {https://doi.org/10.1109/TETC.2020.3019202}
}

• M. Aldinucci, High-performance computing and AI team up for COVID-19 diagnostic imaging, 2021.

The Confederation of Laboratories for Artificial Intelligence Research in Europe (CLAIRE) taskforce on AI & COVID-19 supported the creation of a research group focused on AI-assisted diagnosis of COVID-19 pneumonia. The first results demonstrate the great potential of AI-assisted diagnostic imaging. Furthermore, the impact of the taskforce work is much larger, and it embraces the cross-fertilisation of artificial intelligence (AI) and high-performance computing (HPC): a partnership with rocketing potential for many scientific domains.

@misc{21:covid:aihub,
abstract = {The Confederation of Laboratories for Artificial Intelligence Research in Europe (CLAIRE) taskforce on AI & COVID-19 supported the creation of a research group focused on AI-assisted diagnosis of COVID-19 pneumonia. The first results demonstrate the great potential of AI-assisted diagnostic imaging. Furthermore, the impact of the taskforce work is much larger, and it embraces the cross-fertilisation of artificial intelligence (AI) and high-performance computing (HPC): a partnership with rocketing potential for many scientific domains.},
author = {Marco Aldinucci},
date-modified = {2021-04-17 00:39:37 +0200},
howpublished = {AIhub},
keywords = {deephealth, claire, hpc4ai},
month = jan,
note = {(magazine)},
title = {High-performance computing and {AI} team up for {COVID-19} diagnostic imaging},
url = {https://aihub.org/2021/01/12/high-performance-computing-and-ai-team-up-for-covid-19-diagnostic-imaging/},
year = {2021},
bdsk-url-1 = {https://aihub.org/2021/01/12/high-performance-computing-and-ai-team-up-for-covid-19-diagnostic-imaging/}
}

• F. D’Ascenzo, O. De Filippo, G. Gallone, G. Mittone, M. A. Deriu, M. Iannaccone, A. Ariza-Solé, C. Liebetrau, S. Manzano-Fernández, G. Quadri, T. Kinnaird, G. Campo, J. P. Simao Henriques, J. M. Hughes, A. Dominguez-Rodriguez, M. Aldinucci, U. Morbiducci, G. Patti, S. Raposeiras-Roubin, E. Abu-Assi, G. M. De Ferrari, F. Piroli, A. Saglietto, F. Conrotto, P. Omedé, A. Montefusco, M. Pennone, F. Bruno, P. P. Bocchino, G. Boccuzzi, E. Cerrato, F. Varbella, M. Sperti, S. B. Wilton, L. Velicki, I. Xanthopoulou, A. Cequier, A. Iniguez-Romo, I. Munoz Pousa, M. Cespon Fernandez, B. Caneiro Queija, R. Cobas-Paz, A. Lopez-Cuenca, A. Garay, P. F. Blanco, A. Rognoni, G. Biondi Zoccai, S. Biscaglia, I. Nunez-Gil, T. Fujii, A. Durante, X. Song, T. Kawaji, D. Alexopoulos, Z. Huczek, J. R. Gonzalez Juanatey, S. Nie, M. Kawashiri, I. Colonnelli, B. Cantalupo, R. Esposito, S. Leonardi, W. Grosso Marra, A. Chieffo, U. Michelucci, D. Piga, M. Malavolta, S. Gili, M. Mennuni, C. Montalto, L. Oltrona Visconti, and Y. Arfat, “Machine learning-based prediction of adverse events following an acute coronary syndrome (PRAISE): a modelling study of pooled datasets,” The lancet, vol. 397, iss. 10270, pp. 199-207, 2021. doi:10.1016/S0140-6736(20)32519-8

Background The accuracy of current prediction tools for ischaemic and bleeding events after an acute coronary syndrome (ACS) remains insufficient for individualised patient management strategies. We developed a machine learning-based risk stratification model to predict all-cause death, recurrent acute myocardial infarction, and major bleeding after ACS. Methods Different machine learning models for the prediction of 1-year post-discharge all-cause death, myocardial infarction, and major bleeding (defined as Bleeding Academic Research Consortium type 3 or 5) were trained on a cohort of 19826 adult patients with ACS (split into a training cohort [80%] and internal validation cohort [20%]) from the BleeMACS and RENAMI registries, which included patients across several continents. 25 clinical features routinely assessed at discharge were used to inform the models. The best-performing model for each study outcome (the PRAISE score) was tested in an external validation cohort of 3444 patients with ACS pooled from a randomised controlled trial and three prospective registries. Model performance was assessed according to a range of learning metrics including area under the receiver operating characteristic curve (AUC). Findings The PRAISE score showed an AUC of 0.82 (95% CI 0.78-0.85) in the internal validation cohort and 0.92 (0.90-0.93) in the external validation cohort for 1-year all-cause death; an AUC of 0.74 (0.70-0.78) in the internal validation cohort and 0.81 (0.76-0.85) in the external validation cohort for 1-year myocardial infarction; and an AUC of 0.70 (0.66-0.75) in the internal validation cohort and 0.86 (0.82-0.89) in the external validation cohort for 1-year major bleeding. Interpretation A machine learning-based approach for the identification of predictors of events after an ACS is feasible and effective. The PRAISE score showed accurate discriminative capabilities for the prediction of all-cause death, myocardial infarction, and major bleeding, and might be useful to guide clinical decision making.

@article{21:lancet,
abstract = {Background The accuracy of current prediction tools for ischaemic and bleeding events after an acute coronary syndrome (ACS) remains insufficient for individualised patient management strategies. We developed a machine learning-based risk stratification model to predict all-cause death, recurrent acute myocardial infarction, and major bleeding after ACS.
Methods Different machine learning models for the prediction of 1-year post-discharge all-cause death, myocardial infarction, and major bleeding (defined as Bleeding Academic Research Consortium type 3 or 5) were trained on a cohort of 19826 adult patients with ACS (split into a training cohort [80%] and internal validation cohort [20%]) from the BleeMACS and RENAMI registries, which included patients across several continents. 25 clinical features routinely assessed at discharge were used to inform the models. The best-performing model for each study outcome (the PRAISE score) was tested in an external validation cohort of 3444 patients with ACS pooled from a randomised controlled trial and three prospective registries. Model performance was assessed according to a range of learning metrics including area under the receiver operating characteristic curve (AUC).
Findings The PRAISE score showed an AUC of 0.82 (95% CI 0.78-0.85) in the internal validation cohort and 0.92 (0.90-0.93) in the external validation cohort for 1-year all-cause death; an AUC of 0.74 (0.70-0.78) in the internal validation cohort and 0.81 (0.76-0.85) in the external validation cohort for 1-year myocardial infarction; and an AUC of 0.70 (0.66-0.75) in the internal validation cohort and 0.86 (0.82-0.89) in the external validation cohort for 1-year major bleeding.
Interpretation A machine learning-based approach for the identification of predictors of events after an ACS is feasible and effective. The PRAISE score showed accurate discriminative capabilities for the prediction of all-cause death, myocardial infarction, and major bleeding, and might be useful to guide clinical decision making.},
author = {Fabrizio D'Ascenzo and Ovidio {De Filippo} and Guglielmo Gallone and Gianluca Mittone and Marco Agostino Deriu and Mario Iannaccone and Albert Ariza-Sol\'e and Christoph Liebetrau and Sergio Manzano-Fern\'andez and Giorgio Quadri and Tim Kinnaird and Gianluca Campo and Jose Paulo {Simao Henriques} and James M Hughes and Alberto Dominguez-Rodriguez and Marco Aldinucci and Umberto Morbiducci and Giuseppe Patti and Sergio Raposeiras-Roubin and Emad Abu-Assi and Gaetano Maria {De Ferrari} and Francesco Piroli and Andrea Saglietto and Federico Conrotto and Pierluigi Omed\'e and Antonio Montefusco and Mauro Pennone and Francesco Bruno and Pier Paolo Bocchino and Giacomo Boccuzzi and Enrico Cerrato and Ferdinando Varbella and Michela Sperti and Stephen B. Wilton and Lazar Velicki and Ioanna Xanthopoulou and Angel Cequier and Andres Iniguez-Romo and Isabel {Munoz Pousa} and Maria {Cespon Fernandez} and Berenice {Caneiro Queija} and Rafael Cobas-Paz and Angel Lopez-Cuenca and Alberto Garay and Pedro Flores Blanco and Andrea Rognoni and Giuseppe {Biondi Zoccai} and Simone Biscaglia and Ivan Nunez-Gil and Toshiharu Fujii and Alessandro Durante and Xiantao Song and Tetsuma Kawaji and Dimitrios Alexopoulos and Zenon Huczek and Jose Ramon {Gonzalez Juanatey} and Shao-Ping Nie and Masa-aki Kawashiri and Iacopo Colonnelli and Barbara Cantalupo and Roberto Esposito and Sergio Leonardi and Walter {Grosso Marra} and Alaide Chieffo and Umberto Michelucci and Dario Piga and Marta Malavolta and Sebastiano Gili and Marco Mennuni and Claudio Montalto and Luigi {Oltrona Visconti} and Yasir Arfat},
date-modified = {2021-03-26 23:53:19 +0100},
doi = {10.1016/S0140-6736(20)32519-8},
issn = {0140-6736},
journal = {The Lancet},
keywords = {deephealth, hpc4ai},
number = {10270},
pages = {199-207},
title = {Machine learning-based prediction of adverse events following an acute coronary syndrome {(PRAISE)}: a modelling study of pooled datasets},
volume = {397},
year = {2021},
bdsk-url-2 = {https://doi.org/10.1016/S0140-6736(20)32519-8}
}

• I. Colonnelli, B. Cantalupo, R. Esposito, M. Pennisi, C. Spampinato, and M. Aldinucci, “HPC Application Cloudification: The StreamFlow Toolkit,” in 12th workshop on parallel programming and run-time management techniques for many-core architectures and 10th workshop on design tools and architectures for multicore embedded computing platforms (parma-ditam 2021), Dagstuhl, Germany, 2021, p. 5:1–5:13. doi:10.4230/OASIcs.PARMA-DITAM.2021.5

Finding an effective way to improve accessibility to High-Performance Computing facilities, still anchored to SSH-based remote shells and queue-based job submission mechanisms, is an open problem in computer science. This work advocates a cloudification of HPC applications through a cluster-as-accelerator pattern, where computationally demanding portions of the main execution flow hosted on a Cloud Finding an effective way to improve accessibility to High-Performance Computing facilities, still anchored to SSH-based remote shells and queue-based job submission mechanisms, is an open problem in computer science. This work advocates a cloudification of HPC applications through a cluster-as-accelerator pattern, where computationally demanding portions of the main execution flow hosted on a Cloud infrastructure can be offloaded to HPC environments to speed them up. We introduce StreamFlow, a novel Workflow Management System that supports such a design pattern and makes it possible to run the steps of a standard workflow model on independent processing elements with no shared storage. We validated the proposed approach’s effectiveness on the CLAIRE COVID-19 universal pipeline, i.e. a reproducible workflow capable of automating the comparison of (possibly all) state-of-the-art pipelines for the diagnosis of COVID-19 interstitial pneumonia from CT scans images based on Deep Neural Networks (DNNs).

@inproceedings{colonnelli_et_al:OASIcs.PARMA-DITAM.2021.5,
abstract = {Finding an effective way to improve accessibility to High-Performance Computing facilities, still anchored to SSH-based remote shells and queue-based job submission mechanisms, is an open problem in computer science. This work advocates a cloudification of HPC applications through a cluster-as-accelerator pattern, where computationally demanding portions of the main execution flow hosted on a Cloud Finding an effective way to improve accessibility to High-Performance Computing facilities, still anchored to SSH-based remote shells and queue-based job submission mechanisms, is an open problem in computer science. This work advocates a cloudification of HPC applications through a cluster-as-accelerator pattern, where computationally demanding portions of the main execution flow hosted on a Cloud infrastructure can be offloaded to HPC environments to speed them up. We introduce StreamFlow, a novel Workflow Management System that supports such a design pattern and makes it possible to run the steps of a standard workflow model on independent processing elements with no shared storage. We validated the proposed approach's effectiveness on the CLAIRE COVID-19 universal pipeline, i.e. a reproducible workflow capable of automating the comparison of (possibly all) state-of-the-art pipelines for the diagnosis of COVID-19 interstitial pneumonia from CT scans images based on Deep Neural Networks (DNNs).},
annote = {Keywords: cloud computing, distributed computing, high-performance computing, streamflow, workflow management systems},
author = {Colonnelli, Iacopo and Cantalupo, Barbara and Esposito, Roberto and Pennisi, Matteo and Spampinato, Concetto and Aldinucci, Marco},
booktitle = {12th Workshop on Parallel Programming and Run-Time Management Techniques for Many-core Architectures and 10th Workshop on Design Tools and Architectures for Multicore Embedded Computing Platforms (PARMA-DITAM 2021)},
doi = {10.4230/OASIcs.PARMA-DITAM.2021.5},
editor = {Bispo, Jo\~{a}o and Cherubin, Stefano and Flich, Jos\'{e}},
isbn = {978-3-95977-181-8},
issn = {2190-6807},
keywords = {deephealth, hpc4ai, streamflow},
pages = {5:1--5:13},
publisher = {Schloss Dagstuhl -- Leibniz-Zentrum f{\"u}r Informatik},
series = {Open Access Series in Informatics (OASIcs)},
title = {{HPC Application Cloudification: The StreamFlow Toolkit}},
url = {https://drops.dagstuhl.de/opus/volltexte/2021/13641/pdf/OASIcs-PARMA-DITAM-2021-5.pdf},
urn = {urn:nbn:de:0030-drops-136419},
volume = {88},
year = {2021},
bdsk-url-1 = {https://drops.dagstuhl.de/opus/volltexte/2021/13641/pdf/OASIcs-PARMA-DITAM-2021-5.pdf},
bdsk-url-2 = {https://doi.org/10.4230/OASIcs.PARMA-DITAM.2021.5}
}

• M. Aldinucci, G. Agosta, A. Andreini, C. A. Ardagna, A. Bartolini, A. Cilardo, B. Cosenza, M. Danelutto, R. Esposito, W. Fornaciari, R. Giorgi, D. Lengani, R. Montella, M. Olivieri, S. Saponara, D. Simoni, and M. Torquati, “The Italian research on HPC key technologies across EuroHPC,” in ACM Computing Frontiers, Virtual Conference, Italy, 2021, pp. 279-286. doi:10.1145/3457388.3458508

High-Performance Computing (HPC) is one of the strategic priorities for research and innovation worldwide due to its relevance for industrial and scientific applications. We envision HPC as composed of three pillars: infrastructures, applications, and key technologies and tools. While infrastructures are by construction centralized in large-scale HPC centers, and applications are generally within the purview of domain-specific organizations, key technologies fall in an intermediate case where coordination is needed, but design and development are often decentralized. A large group of Italian researchers has started a dedicated laboratory within the National Interuniversity Consortium for Informatics (CINI) to address this challenge. The laboratory, albeit young, has managed to succeed in its first attempts to propose a coordinated approach to HPC research within the EuroHPC Joint Undertaking, participating in the calls 2019-20 to five successful proposals for an aggregate total cost of 95M Euro. In this paper, we outline the working group’s scope and goals and provide an overview of the five funded projects, which become fully operational in March 2021, and cover a selection of key technologies provided by the working group partners, highlighting their usage development within the projects.

@inproceedings{21:CINI_acm_CF,
abstract = {High-Performance Computing (HPC) is one of the strategic priorities for research and innovation worldwide due to its relevance for industrial and scientific applications. We envision HPC as composed of three pillars: infrastructures, applications, and key technologies and tools. While infrastructures are by construction centralized in large-scale HPC centers, and applications are generally within the purview of domain-specific organizations, key technologies fall in an intermediate case where coordination is needed, but design and development are often decentralized. A large group of Italian researchers has started a dedicated laboratory within the National Interuniversity Consortium for Informatics (CINI) to address this challenge. The laboratory, albeit young, has managed to succeed in its first attempts to propose a coordinated approach to HPC research within the EuroHPC Joint Undertaking, participating in the calls 2019-20 to five successful proposals for an aggregate total cost of 95M Euro. In this paper, we outline the working group's scope and goals and provide an overview of the five funded projects, which become fully operational in March 2021, and cover a selection of key technologies provided by the working group partners, highlighting their usage development within the projects.},
author = {Marco Aldinucci and Giovanni Agosta and Antonio Andreini and Claudio A. Ardagna and Andrea Bartolini and Alessandro Cilardo and Biagio Cosenza and Marco Danelutto and Roberto Esposito and William Fornaciari and Roberto Giorgi and Davide Lengani and Raffaele Montella and Mauro Olivieri and Sergio Saponara and Daniele Simoni and Massimo Torquati},
booktitle = {{ACM Computing Frontiers}},
date-modified = {2021-03-26 23:18:32 +0100},
doi = {10.1145/3457388.3458508},
keywords = {across, admire, textarossa, eupex, eupilot},
month = may,
pages = {279-286},
publisher = {ACM},
title = {The {Italian} research on {HPC} key technologies across {EuroHPC}},
url = {https://iris.unito.it/retrieve/handle/2318/1783118/744641/preprint.pdf},
year = {2021},
bdsk-url-1 = {https://iris.unito.it/retrieve/handle/2318/1765596/689772/2018_hpc4ai_ACM_CF.pdf},
bdsk-url-2 = {https://doi.org/10.1145/3203217.3205340}
}

• M. Aldinucci, “L’infrastruttura necessaria per creare interoperabilità tra pubbliche amministrazioni,” in L’amministrazione pubblica con i big data: da torino un dibattito sull’intelligenza artificiale, R. Cavallo Perin, Ed., , 2021, pp. 225-232.

L’articolo affronta il tema dell’interoperabilità dal punto di vista informatico, ponendo l’accento sulle infrastrutture necessarie affinché la comunicazione tra sistemi informatici pubblici sia possibile. La struttura a silos su cui si basa il sistema informativo della pubblica amministrazione italiana risulta inadeguato all’approccio della big data analysis che, a contrario, richiede la piena comunicabilità tra sistemi informativi affinché il reperimento dei dati su cui condurre sperimentazioni sia quanto più facile e mirato.

@incollection{21:bigdata:ius,
abstract = {L'articolo affronta il tema dell'interoperabilit{\a} dal punto di vista informatico, ponendo l'accento sulle infrastrutture necessarie affinch{\'e} la comunicazione tra sistemi informatici pubblici sia possibile. La struttura a silos su cui si basa il sistema informativo della pubblica amministrazione italiana risulta inadeguato all'approccio della big data analysis che, a contrario, richiede la piena comunicabilit{\a} tra sistemi informativi affinch{\'e} il reperimento dei dati su cui condurre sperimentazioni sia quanto pi{\u} facile e mirato.},
author = {Marco Aldinucci},
booktitle = {L'amministrazione pubblica con i big data: da Torino un dibattito sull'intelligenza artificiale},
chapter = {15},
editor = {Cavallo Perin, Roberto},
isbn = {9788875901806},
pages = {225-232},
title = {L'infrastruttura necessaria per creare interoperabilit{\a} tra pubbliche amministrazioni},
url = {https://iris.unito.it/retrieve/handle/2318/1784335/748058/15.Aldinucci.pdf},
year = {2021},
bdsk-url-1 = {https://iris.unito.it/retrieve/handle/2318/1784335/748058/15.Aldinucci.pdf}
}

• G. Agosta, W. Fornaciari, A. Galimberti, G. Massari, F. Reghenzani, F. Terraneo, D. Zoni, C. Brandolese, M. Celino, F. Iannone, P. Palazzari, G. Zummo, M. Bernaschi, P. D’Ambra, S. Saponara, M. Danelutto, M. Torquati, M. Aldinucci, Y. Arfat, B. Cantalupo, I. Colonnelli, R. Esposito, A. R. Martinelli, G. Mittone, O. Beaumont, B. Bramas, L. Eyraud-Dubois, B. Goglin, A. Guermouche, R. Namyst, S. Thibault, A. Filgueras, M. Vidal, C. Alvarez, X. Martorell, A. Oleksiak, M. Kulczewski, A. Lonardo, P. Vicini, F. L. Cicero, F. Simula, A. Biagioni, P. Cretaro, O. Frezza, P. S. Paolucci, M. Turisini, F. Giacomini, T. Boccali, S. Montangero, and R. Ammendola, “TEXTAROSSA: towards extreme scale technologies and accelerators for eurohpc hw/sw supercomputing applications for exascale,” in Proc. of the 24th euromicro conference on digital system design (DSD), Palermo, Italy, 2021. doi:10.1109/DSD53832.2021.00051
[BibTeX] [Abstract]

To achieve high performance and high energy effi- ciency on near-future exascale computing systems, three key technology gaps needs to be bridged. These gaps include: en- ergy efficiency and thermal control; extreme computation effi- ciency via HW acceleration and new arithmetics; methods and tools for seamless integration of reconfigurable accelerators in heterogeneous HPC multi-node platforms. TEXTAROSSA aims at tackling this gap through a co-design approach to heterogeneous HPC solutions, supported by the integration and extension of HW and SW IPs, programming models and tools derived from European research.

@inproceedings{21:DSD:textarossa,
abstract = {To achieve high performance and high energy effi- ciency on near-future exascale computing systems, three key technology gaps needs to be bridged. These gaps include: en- ergy efficiency and thermal control; extreme computation effi- ciency via HW acceleration and new arithmetics; methods and tools for seamless integration of reconfigurable accelerators in heterogeneous HPC multi-node platforms. TEXTAROSSA aims at tackling this gap through a co-design approach to heterogeneous HPC solutions, supported by the integration and extension of HW and SW IPs, programming models and tools derived from European research.},
author = {Giovanni Agosta and William Fornaciari and Andrea Galimberti and Giuseppe Massari and Federico Reghenzani and Federico Terraneo and Davide Zoni and Carlo Brandolese and Massimo Celino and Francesco Iannone and Paolo Palazzari and Giuseppe Zummo and Massimo Bernaschi and Pasqua D'Ambra and Sergio Saponara and Marco Danelutto and Massimo Torquati and Marco Aldinucci and Yasir Arfat and Barbara Cantalupo and Iacopo Colonnelli and Roberto Esposito and Alberto Riccardo Martinelli and Gianluca Mittone and Olivier Beaumont and Berenger Bramas and Lionel Eyraud-Dubois and Brice Goglin and Abdou Guermouche and Raymond Namyst and Samuel Thibault and Antonio Filgueras and Miquel Vidal and Carlos Alvarez and Xavier Martorell and Ariel Oleksiak and Michal Kulczewski and Alessandro Lonardo and Piero Vicini and Francesco Lo Cicero and Francesco Simula and Andrea Biagioni and Paolo Cretaro and Ottorino Frezza and Pier Stanislao Paolucci and Matteo Turisini and Francesco Giacomini and Tommaso Boccali and Simone Montangero and Roberto Ammendola},
booktitle = {Proc. of the 24th Euromicro Conference on Digital System Design ({DSD})},
date-modified = {2021-09-04 12:23:41 +0200},
doi = {10.1109/DSD53832.2021.00051},
keywords = {textarossa, streamflow},
month = aug,
publisher = {IEEE},
title = {{TEXTAROSSA}: Towards EXtreme scale Technologies and Accelerators for euROhpc hw/Sw Supercomputing Applications for exascale},
year = {2021},
bdsk-url-1 = {https://doi.org/10.1109/DSD53832.2021.00051}
}

• D. D’Agostino, P. Liò, M. Aldinucci, and I. Merelli, “Advantages of using graph databases to explore chromatin conformation capture experiments,” BMC bioinformatics, vol. 22, iss. 2, pp. 43-58, 2021. doi:10.1186/s12859-020-03937-0

High-throughput sequencing Chromosome Conformation Capture (Hi-C) allows the study of DNA interactions and 3D chromosome folding at the genome-wide scale. Usually, these data are represented as matrices describing the binary contacts among the different chromosome regions. On the other hand, a graph-based representation can be advantageous to describe the complex topology achieved by the DNA in the nucleus of eukaryotic cells.

@article{21:neohic:bmc,
abstract = {High-throughput sequencing Chromosome Conformation Capture (Hi-C) allows the study of DNA interactions and 3D chromosome folding at the genome-wide scale. Usually, these data are represented as matrices describing the binary contacts among the different chromosome regions. On the other hand, a graph-based representation can be advantageous to describe the complex topology achieved by the DNA in the nucleus of eukaryotic cells.},
annote = {https://iris.unito.it/retrieve/handle/2318/1787302/756557/2021_neohic_BMC.pdf},
author = {D'Agostino, Daniele and Li{\o}, Pietro and Aldinucci, Marco and Merelli, Ivan},
da = {2021/04/26},
date-modified = {2021-04-26 15:42:52 +0200},
doi = {10.1186/s12859-020-03937-0},
isbn = {1471-2105},
journal = {{BMC} Bioinformatics},
keywords = {deephealth, hpc4ai},
number = {2},
pages = {43-58},
title = {Advantages of using graph databases to explore chromatin conformation capture experiments},
url = {https://bmcbioinformatics.biomedcentral.com/track/pdf/10.1186/s12859-020-03937-0.pdf},
volume = {22},
year = {2021},
bdsk-url-1 = {https://doi.org/10.1186/s12859-020-03937-0}
}

• D. D’Agostino, I. Merelli, M. Aldinucci, and D. Cesini, “Hardware and software solutions for energy-efficient computing in scientific programming,” Scientific programming, vol. 2021, p. 5514284, 2021. doi:10.1155/2021/5514284

Energy consumption is one of the major issues in today&{\#}x2019;s computer science, and an increasing number of scientific communities are interested in evaluating the tradeoff between time-to-solution and energy-to-solution. Despite, in the last two decades, computing which revolved around centralized computing infrastructures, such as supercomputing and data centers, the wide adoption of the Internet of Things (IoT) paradigm is currently inverting this trend due to the huge amount of data it generates, pushing computing power back to places where the data are generated&{\#}x2014;the so-called fog/edge computing. This shift towards a decentralized model requires an equivalent change in the software engineering paradigms, development environments, hardware tools, languages, and computation models for scientific programming because the local computational capabilities are typically limited and require a careful evaluation of power consumption. This paper aims to present how these concepts can be actually implemented in scientific software by presenting the state of the art of powerful, less power-hungry processors from one side and energy-aware tools and techniques from the other one.

@article{21:dagostino:lowpower,
abstract = {Energy consumption is one of the major issues in today\&{\#}x2019;s computer science, and an increasing number of scientific communities are interested in evaluating the tradeoff between time-to-solution and energy-to-solution. Despite, in the last two decades, computing which revolved around centralized computing infrastructures, such as supercomputing and data centers, the wide adoption of the Internet of Things (IoT) paradigm is currently inverting this trend due to the huge amount of data it generates, pushing computing power back to places where the data are generated\&{\#}x2014;the so-called fog/edge computing. This shift towards a decentralized model requires an equivalent change in the software engineering paradigms, development environments, hardware tools, languages, and computation models for scientific programming because the local computational capabilities are typically limited and require a careful evaluation of power consumption. This paper aims to present how these concepts can be actually implemented in scientific software by presenting the state of the art of powerful, less power-hungry processors from one side and energy-aware tools and techniques from the other one.},
author = {D'Agostino, Daniele and Merelli, Ivan and Aldinucci, Marco and Cesini, Daniele},
da = {2021/06/09},
date-modified = {2021-06-10 22:46:34 +0200},
doi = {10.1155/2021/5514284},
isbn = {1058-9244},
journal = {Scientific Programming},
pages = {5514284},
publisher = {Hindawi},
title = {Hardware and Software Solutions for Energy-Efficient Computing in Scientific Programming},
ty = {JOUR},
volume = {2021},
year = {2021},
bdsk-url-1 = {https://doi.org/10.1155/2021/5514284}
}

• M. Aldinucci, V. Cesare, I. Colonnelli, A. R. Martinelli, G. Mittone, B. Cantalupo, C. Cavazzoni, and M. Drocco, “Practical parallelization of scientific applications with OpenMP, OpenACC and MPI,” Journal of parallel and distributed computing, vol. 157, pp. 13-29, 2021. doi:10.1016/j.jpdc.2021.05.017

This work aims at distilling a systematic methodology to modernize existing sequential scientific codes with a little re-designing effort, turning an old codebase into \emph{modern} code, i.e., parallel and robust code. We propose a semi-automatic methodology to parallelize scientific applications designed with a purely sequential programming mindset, possibly using global variables, aliasing, random number generators, and stateful functions. We demonstrate that the same methodology works for the parallelization in the shared memory model (via OpenMP), message passing model (via MPI), and General Purpose Computing on GPU model (via OpenACC). The method is demonstrated parallelizing four real-world sequential codes in the domain of physics and material science. The methodology itself has been distilled in collaboration with MSc students of the Parallel Computing course at the University of Torino, that applied it for the first time to the project works that they presented for the final exam of the course. Every year the course hosts some special lectures from industry representatives, who present how they use parallel computing and offer codes to be parallelized.

@article{21:jpdc:loop,
abstract = {This work aims at distilling a systematic methodology to modernize existing sequential scientific codes with a little re-designing effort, turning an old codebase into \emph{modern} code, i.e., parallel and robust code. We propose a semi-automatic methodology to parallelize scientific applications designed with a purely sequential programming mindset, possibly using global variables, aliasing, random number generators, and stateful functions. We demonstrate that the same methodology works for the parallelization in the shared memory model (via OpenMP), message passing model (via MPI), and General Purpose Computing on GPU model (via OpenACC). The method is demonstrated parallelizing four real-world sequential codes in the domain of physics and material science. The methodology itself has been distilled in collaboration with MSc students of the Parallel Computing course at the University of Torino, that applied it for the first time to the project works that they presented for the final exam of the course. Every year the course hosts some special lectures from industry representatives, who present how they use parallel computing and offer codes to be parallelized. },
author = {Aldinucci, Marco and Cesare, Valentina and Colonnelli, Iacopo and Martinelli, Alberto Riccardo and Mittone, Gianluca and Cantalupo, Barbara and Cavazzoni, Carlo and Drocco, Maurizio},
date-modified = {2021-06-10 22:30:05 +0200},
doi = {10.1016/j.jpdc.2021.05.017},
journal = {Journal of Parallel and Distributed Computing},
keywords = {saperi},
pages = {13-29},
title = {Practical Parallelization of Scientific Applications with {OpenMP, OpenACC and MPI}},
url = {https://iris.unito.it/retrieve/handle/2318/1792557/770851/Practical_Parallelization_JPDC_preprint.pdf},
volume = {157},
year = {2021},
bdsk-url-1 = {https://iris.unito.it/retrieve/handle/2318/1792557/770851/Practical_Parallelization_JPDC_preprint.pdf},
bdsk-url-2 = {https://doi.org/10.1016/j.jpdc.2021.05.017}
}

• Y. Arfat, G. Mittone, R. Esposito, B. Cantalupo, G. M. De Ferrari, and M. Aldinucci, “A review of machine learning for cardiology,” Minerva cardiology and angiology, 2021. doi:10.23736/s2724-5683.21.05709-4

This paper reviews recent cardiology literature and reports how Artificial Intelligence Tools (specifically, Machine Learning techniques) are being used by physicians in the field. Each technique is introduced with enough details to allow the understanding of how it works and its intent, but without delving into details that do not add immediate benefits and require expertise in the field. We specifically focus on the principal Machine Learning based risk scores used in cardiovascular research. After introducing them and summarizing their assumptions and biases, we discuss their merits and shortcomings. We report on how frequently they are adopted in the field and suggest why this is the case based on our expertise in Machine Learning. We complete the analysis by reviewing how corresponding statistical approaches compare with them. Finally, we discuss the main open issues in applying Machine Learning tools to cardiology tasks, also drafting possible future directions. Despite the growing interest in these tools, we argue that there are many still underutilized techniques: while Neural Networks are slowly being incorporated in cardiovascular research, other important techniques such as Semi-Supervised Learning and Federated Learning are still underutilized. The former would allow practitioners to harness the information contained in large datasets that are only partially labeled, while the latter would foster collaboration between institutions allowing building larger and better models.

@article{21:ai4numbers:minerva,
abstract = {This paper reviews recent cardiology literature and reports how Artificial Intelligence Tools (specifically, Machine Learning techniques) are being used by physicians in the field. Each technique is introduced with enough details to allow the understanding of how it works and its intent, but without delving into details that do not add immediate benefits and require expertise in the field. We specifically focus on the principal Machine Learning based risk scores used in cardiovascular research. After introducing them and summarizing their assumptions and biases, we discuss their merits and shortcomings. We report on how frequently they are adopted in the field and suggest why this is the case based on our expertise in Machine Learning. We complete the analysis by reviewing how corresponding statistical approaches compare with them. Finally, we discuss the main open issues in applying Machine Learning tools to cardiology tasks, also drafting possible future directions. Despite the growing interest in these tools, we argue that there are many still underutilized techniques: while Neural Networks are slowly being incorporated in cardiovascular research, other important techniques such as Semi-Supervised Learning and Federated Learning are still underutilized. The former would allow practitioners to harness the information contained in large datasets that are only partially labeled, while the latter would foster collaboration between institutions allowing building larger and better models.},
author = {Yasir Arfat and Gianluca Mittone and Roberto Esposito and Barbara Cantalupo and Gaetano Maria {De Ferrari} and Marco Aldinucci},
date-modified = {2021-08-09 23:05:36 +0200},
doi = {10.23736/s2724-5683.21.05709-4},
journal = {Minerva cardiology and angiology},
keywords = {deephealth, hpc4ai},
title = {A Review of Machine Learning for Cardiology},
url = {https://iris.unito.it/retrieve/handle/2318/1796298/780512/21_AI4numbers-preprint.pdf},
year = {2021},
bdsk-url-1 = {https://iris.unito.it/retrieve/handle/2318/1796298/780512/21_AI4numbers-preprint.pdf},
bdsk-url-2 = {https://doi.org/10.23736/s2724-5683.21.05709-4}
}

• I. Colonnelli, B. Cantalupo, C. Spampinato, M. Pennisi, and M. Aldinucci, “Bringing ai pipelines onto cloud-hpc: setting a baseline for accuracy of covid-19 diagnosis,” in Enea cresco in the fight against covid-19, 2021. doi:10.5281/zenodo.5151511

HPC is an enabling platform for AI. The introduction of AI workloads in the HPC applications basket has non-trivial consequences both on the way of designing AI applications and on the way of providing HPC computing. This is the leitmotif of the convergence between HPC and AI. The formalized definition of AI pipelines is one of the milestones of HPC-AI convergence. If well conducted, it allows, on the one hand, to obtain portable and scalable applications. On the other hand, it is crucial for the reproducibility of scientific pipelines. In this work, we advocate the StreamFlow Workflow Management System as a crucial ingredient to define a parametric pipeline, called “CLAIRE COVID-19 Universal Pipeline”, which is able to explore the optimization space of methods to classify COVID-19 lung lesions from CT scans, compare them for accuracy, and therefore set a performance baseline. The universal pipeline automatizes the training of many different Deep Neural Networks (DNNs) and many different hyperparameters. It, therefore, requires a massive computing power, which is found in traditional HPC infrastructure thanks to the portability-by-design of pipelines designed with StreamFlow. Using the universal pipeline, we identified a DNN reaching over 90\% accuracy in detecting COVID-19 lesions in CT scans.

@inproceedings{21:covi:enea,
abstract = {HPC is an enabling platform for AI. The introduction of AI workloads in the HPC applications basket has non-trivial consequences both on the way of designing AI applications and on the way of providing HPC computing. This is the leitmotif of the convergence between HPC and AI. The formalized definition of AI pipelines is one of the milestones of HPC-AI convergence. If well conducted, it allows, on the one hand, to obtain portable and scalable applications. On the other hand, it is crucial for the reproducibility of scientific pipelines. In this work, we advocate the StreamFlow Workflow Management System as a crucial ingredient to define a parametric pipeline, called CLAIRE COVID-19 Universal Pipeline'', which is able to explore the optimization space of methods to classify COVID-19 lung lesions from CT scans, compare them for accuracy, and therefore set a performance baseline. The universal pipeline automatizes the training of many different Deep Neural Networks (DNNs) and many different hyperparameters. It, therefore, requires a massive computing power, which is found in traditional HPC infrastructure thanks to the portability-by-design of pipelines designed with StreamFlow. Using the universal pipeline, we identified a DNN reaching over 90\% accuracy in detecting COVID-19 lesions in CT scans.},
author = {Colonnelli, Iacopo and Cantalupo, Barbara and Spampinato, Concetto and Pennisi, Matteo and Aldinucci, Marco},
booktitle = {ENEA CRESCO in the fight against COVID-19},
doi = {10.5281/zenodo.5151511},
editor = {Francesco Iannone},
keywords = {streamflow},
publisher = {ENEA},
title = {Bringing AI pipelines onto cloud-HPC: setting a baseline for accuracy of COVID-19 diagnosis},
url = {https://iris.unito.it/retrieve/handle/2318/1796029/779853/21_AI-pipelines_ENEA-COVID19.pdf},
year = {2021},
bdsk-url-1 = {https://iris.unito.it/retrieve/handle/2318/1796029/779853/21_AI-pipelines_ENEA-COVID19.pdf},
bdsk-url-2 = {https://doi.org/10.5281/zenodo.5151511}
}

• M. Aldinucci, V. Cesare, I. Colonnelli, A. R. Martinelli, G. Mittone, and B. Cantalupo, “Practical parallelizazion of a Laplace solver with MPI,” in Enea cresco in the fight against covid-19, 2021, p. 21–24.
[BibTeX] [Abstract]

This work exposes a practical methodology for the semi-automatic parallelization of existing code. We show how a scientific sequential code can be parallelized through our approach. The obtained parallel code is only slightly different from the starting sequential one, providing an example of how little re-designing our methodology involves. The performance of the parallelized code, executed on the CRESCO6 cluster, is then exposed and discussed. We also believe in the educational value of this approach and suggest its use as a teaching device for students.

@inproceedings{21:laplace:enea,
abstract = {This work exposes a practical methodology for the semi-automatic parallelization of existing code. We show how a scientific sequential code can be parallelized through our approach. The obtained parallel code is only slightly different from the starting sequential one, providing an example of how little re-designing our methodology involves. The performance of the parallelized code, executed on the CRESCO6 cluster, is then exposed and discussed. We also believe in the educational value of this approach and suggest its use as a teaching device for students.},
author = {Aldinucci, Marco and Cesare, Valentina and Colonnelli, Iacopo and Martinelli, Alberto Riccardo and Mittone, Gianluca and Cantalupo, Barbara},
booktitle = {ENEA CRESCO in the fight against COVID-19},
editor = {Francesco Iannone},
keywords = {hpc4ai},
pages = {21--24},
publisher = {ENEA},
title = {Practical Parallelizazion of a {Laplace} Solver with {MPI}},
year = {2021}
}

• M. Pennisi, I. Kavasidis, C. Spampinato, V. Schinina, S. Palazzo, F. P. Salanitri, G. Bellitto, F. Rundo, M. Aldinucci, M. Cristofaro, and others, “An explainable AI system for automated COVID-19 assessment and lesion categorization from CT-scans,” Artificial intelligence in medicine, p. 102114, 2021. doi:10.1016/j.artmed.2021.102114

COVID-19 infection caused by SARS-CoV-2 pathogen has been a catastrophic pandemic outbreak all over the world, with exponential increasing of confirmed cases and, unfortunately, deaths. In this work we propose an AI-powered pipeline, based on the deep-learning paradigm, for automated COVID-19 detection and lesion categorization from CT scans. We first propose a new segmentation module aimed at automatically identifying lung parenchyma and lobes. Next, we combine the segmentation network with classification networks for COVID-19 identification and lesion categorization. We compare the model’s classification results with those obtained by three expert radiologists on a dataset of 166 CT scans. Results showed a sensitivity of 90.3\% and a specificity of 93.5\% for COVID-19 detection, at least on par with those yielded by the expert radiologists, and an average lesion categorization accuracy of about 84\%. Moreover, a significant role is played by prior lung and lobe segmentation, that allowed us to enhance classification performance by over 6 percent points. The interpretation of the trained AI models reveals that the most significant areas for supporting the decision on COVID-19 identification are consistent with the lesions clinically associated to the virus, i.e., crazy paving, consolidation and ground glass. This means that the artificial models are able to discriminate a positive patient from a negative one (both controls and patients with interstitial pneumonia tested negative to COVID) by evaluating the presence of those lesions into CT scans. Finally, the AI models are integrated into a user-friendly GUI to support AI explainability for radiologists, which is publicly available at http://perceivelab.com/covid-ai. The whole AI system is unique since, to the best of our knowledge, it is the first AI-based software, publicly available, that attempts to explain to radiologists what information is used by AI methods for making decisions and that proactively involves them in the decision loop to further improve the COVID-19 understanding.

@article{pennisi2021explainable,
abstract = {COVID-19 infection caused by SARS-CoV-2 pathogen has been a catastrophic pandemic outbreak all over the world, with exponential increasing of confirmed cases and, unfortunately, deaths. In this work we propose an AI-powered pipeline, based on the deep-learning paradigm, for automated COVID-19 detection and lesion categorization from CT scans. We first propose a new segmentation module aimed at automatically identifying lung parenchyma and lobes. Next, we combine the segmentation network with classification networks for COVID-19 identification and lesion categorization. We compare the model's classification results with those obtained by three expert radiologists on a dataset of 166 CT scans. Results showed a sensitivity of 90.3\% and a specificity of 93.5\% for COVID-19 detection, at least on par with those yielded by the expert radiologists, and an average lesion categorization accuracy of about 84\%. Moreover, a significant role is played by prior lung and lobe segmentation, that allowed us to enhance classification performance by over 6 percent points. The interpretation of the trained AI models reveals that the most significant areas for supporting the decision on COVID-19 identification are consistent with the lesions clinically associated to the virus, i.e., crazy paving, consolidation and ground glass. This means that the artificial models are able to discriminate a positive patient from a negative one (both controls and patients with interstitial pneumonia tested negative to COVID) by evaluating the presence of those lesions into CT scans. Finally, the AI models are integrated into a user-friendly GUI to support AI explainability for radiologists, which is publicly available at http://perceivelab.com/covid-ai. The whole AI system is unique since, to the best of our knowledge, it is the first AI-based software, publicly available, that attempts to explain to radiologists what information is used by AI methods for making decisions and that proactively involves them in the decision loop to further improve the COVID-19 understanding.},
author = {Pennisi, Matteo and Kavasidis, Isaak and Spampinato, Concetto and Schinina, Vincenzo and Palazzo, Simone and Salanitri, Federica Proietto and Bellitto, Giovanni and Rundo, Francesco and Aldinucci, Marco and Cristofaro, Massimo and others},
doi = {10.1016/j.artmed.2021.102114},
journal = {Artificial Intelligence in Medicine},
keynote = {deephealth},
pages = {102114},
publisher = {Elsevier},
title = {An Explainable {AI} System for Automated {COVID-19} Assessment and Lesion Categorization from {CT-scans}},
url = {https://iris.unito.it/retrieve/handle/2318/1792619/770952/2021_COVID_AIM_preprint.pdf},
year = {2021},
bdsk-url-1 = {https://iris.unito.it/retrieve/handle/2318/1792619/770952/2021_COVID_AIM_preprint.pdf},
bdsk-url-2 = {https://doi.org/10.1016/j.artmed.2021.102114}
}

### 2020

• M. Aldinucci, Polmonite da COVID-19, diagnosi con l’intelligenza artificiale: italia in prima fila, 2020.

La Task Force su AI&COVID-19 della confederazione europea dei laboratori di ricerca sull’intelligenza artificiale (CLAIRE) ha sostenuto la creazione di un gruppo di ricerca focalizzato sulla diagnosi della polmonite da COVID assistita dall’Intelligenza Artificiale. I primi risultati sono incoraggianti

@misc{20:covid:ag,
abstract = {La Task Force su AI&COVID-19 della confederazione europea dei laboratori di ricerca sull'intelligenza artificiale (CLAIRE) ha sostenuto la creazione di un gruppo di ricerca focalizzato sulla diagnosi della polmonite da COVID assistita dall'Intelligenza Artificiale. I primi risultati sono incoraggianti},
author = {Marco Aldinucci},
date-modified = {2021-04-17 00:42:11 +0200},
howpublished = {Agenda Digitale},
keywords = {deephealth, claire, hpc4ai},
month = nov,
note = {(magazine)},
title = {Polmonite da {COVID-19}, diagnosi con l'intelligenza artificiale: Italia in prima fila},
year = {2020},
}

• P. Metzger, M. Cole, C. Fensch, M. Aldinucci, and E. Bini, “Enforcing deadlines for skeleton-based parallel programming,” in 26th IEEE real-time and embedded technology and applications symposium (RTAS), Sydney, Australia, 2020. doi:10.1109/RTAS48715.2020.000-7

High throughput applications with real-time guar- antees are increasingly relevant. For these applications, parallelism must be exposed to meet deadlines. Directed Acyclic Graphs (DAGs) are a popular and very general application model that can capture any possible interaction among threads. However, we argue that by constraining the application structure to a set of composable “skeletons”, at the price of losing some generality w.r.t. DAGs, the following advantages are gained: (i) a finer model of the application enables tighter analysis, (ii) specialised scheduling policies are applicable, (iii) programming is simplified, (iv) specialised implementation techniques can be exploited transparently, and (v) the program can be automatically tuned to minimise resource usage while still meeting its hard deadlines. As a first step towards a set of real-time skeletons we conduct a case study with the job farm skeleton and the hard real- time XMOS xCore-200 microcontroller. We present an analytical framework for job farms that reduces the number of required cores by scheduling jobs in batches, while ensuring that deadlines are still met. Our experimental results demonstrate that batching reduces the minimum sustainable period by up to 22%, leading to a reduced number of required cores. The framework chooses the best parameters in 83% of cases and never selects parameters that cause deadline misses. Finally, we show that the overheads introduced by the skeleton abstraction layer are negligible.

@inproceedings{20:farm:rtas,
abstract = {High throughput applications with real-time guar- antees are increasingly relevant. For these applications, parallelism must be exposed to meet deadlines. Directed Acyclic Graphs (DAGs) are a popular and very general application model that can capture any possible interaction among threads. However, we argue that by constraining the application structure to a set of composable skeletons'', at the price of losing some generality w.r.t. DAGs, the following advantages are gained: (i) a finer model of the application enables tighter analysis, (ii) specialised scheduling policies are applicable, (iii) programming is simplified, (iv) specialised implementation techniques can be exploited transparently, and (v) the program can be automatically tuned to minimise resource usage while still meeting its hard deadlines.
As a first step towards a set of real-time skeletons we conduct a case study with the job farm skeleton and the hard real- time XMOS xCore-200 microcontroller. We present an analytical framework for job farms that reduces the number of required cores by scheduling jobs in batches, while ensuring that deadlines are still met. Our experimental results demonstrate that batching reduces the minimum sustainable period by up to 22%, leading to a reduced number of required cores. The framework chooses the best parameters in 83% of cases and never selects parameters that cause deadline misses. Finally, we show that the overheads introduced by the skeleton abstraction layer are negligible.
},
author = {Paul Metzger and Murray Cole and Christian Fensch and Marco Aldinucci and Enrico Bini},
booktitle = {26th {IEEE} Real-Time and Embedded Technology and Applications Symposium ({RTAS})},
date-modified = {2020-02-27 00:13:59 +0100},
doi = {10.1109/RTAS48715.2020.000-7},
title = {Enforcing Deadlines for Skeleton-based Parallel Programming},
url = {https://iris.unito.it/retrieve/handle/2318/1741320/616056/20_ske_RTAS.pdf},
year = {2020},
bdsk-url-1 = {https://iris.unito.it/retrieve/handle/2318/1741320/616056/20_ske_RTAS.pdf},
bdsk-url-2 = {https://doi.org/10.1109/RTAS48715.2020.000-7}
}

• V. Cesare, I. Colonnelli, and M. Aldinucci, “Practical parallelization of scientific applications,” in Proc. of 28th euromicro intl. conference on parallel distributed and network-based processing (pdp), Västerås, Sweden, 2020, pp. 376-384. doi:10.1109/PDP50117.2020.00064

This work aims at distilling a systematic methodology to modernize existing sequential scientific codes with a limited re-designing effort, turning an old codebase into modern code, i.e., parallel and robust code. We propose an automatable methodology to parallelize scientific applications designed with a purely sequential programming mindset, thus possibly using global variables, aliasing, random number generators, and stateful functions. We demonstrate the methodology by way of an astrophysical application, where we model at the same time the kinematic profiles of 30 disk galaxies with a Monte Carlo Markov Chain (MCMC), which is sequential by definition. The parallel code exhibits a 12 times speedup on a 48-core platform.

@inproceedings{20:looppar:pdp,
abstract = {This work aims at distilling a systematic methodology to modernize existing sequential scientific codes with a limited re-designing effort, turning an old codebase into modern code, i.e., parallel and robust code. We propose an automatable methodology to parallelize scientific applications designed with a purely sequential programming mindset, thus possibly using global variables, aliasing, random number generators, and stateful functions. We demonstrate the methodology by way of an astrophysical application, where we model at the same time the kinematic profiles of 30 disk galaxies with a Monte Carlo Markov Chain (MCMC), which is sequential by definition. The parallel code exhibits a 12 times speedup on a 48-core platform.},
author = {Valentina Cesare and Iacopo Colonnelli and Marco Aldinucci},
booktitle = {Proc. of 28th Euromicro Intl. Conference on Parallel Distributed and network-based Processing (PDP)},
date-modified = {2020-04-05 02:21:31 +0200},
doi = {10.1109/PDP50117.2020.00064},
keywords = {hpc4ai, c3s},
pages = {376-384},
publisher = {IEEE},
title = {Practical Parallelization of Scientific Applications},
url = {https://iris.unito.it/retrieve/handle/2318/1735377/601141/2020_looppar_PDP.pdf},
year = {2020},
bdsk-url-1 = {https://doi.org/10.1109/PDP50117.2020.00064},
bdsk-url-2 = {https://iris.unito.it/retrieve/handle/2318/1735377/601141/2020_looppar_PDP.pdf}
}

• J. D. Garcia, J. D. del Rio, M. Aldinucci, F. Tordini, M. Danelutto, G. Mencagli, and M. Torquati, “Challenging the abstraction penalty in parallel patterns libraries: adding fastflow support to grppi,” The journal of supercomputing, vol. 76, iss. 7, pp. 5139-5159, 2020. doi:10.1007/s11227-019-02826-5

In the last years, pattern-based programming has been recognized as a good practice for efficiently exploiting parallel hardware resources. Following this approach, multiple libraries have been designed for providing such high-level abstractions to ease the parallel programming. However, those libraries do not share a common interface. To pave the way, GrPPI has been designed for providing an intermediate abstraction layer between application developers and existing parallel programming frameworks like OpenMP, Intel TBB or ISO C++ threads. On the other hand, FastFlow has been adopted as an efficient object-based programming framework that may benefit from being supported as an additional GrPPI backend. However, the object-based approach presents some major challenges to be incorporated under the GrPPI type safe functional programming style. In this paper, we present the integration of FastFlow as a new GrPPI backend to demonstrate that structured parallel programming frameworks perfectly fit the GrPPI design. Additionally, we also demonstrate that GrPPI does not incur in additional overheads for providing its abstraction layer, and we study the programmability in terms of lines of code and cyclomatic complexity. In general, the presented work acts as reciprocal validation of both FastFlow (as an efficient, native structured parallel programming framework) and GrPPI (as an efficient abstraction layer on top of existing parallel programming frameworks).

@article{19:jsupe:grppi,
abstract = {In the last years, pattern-based programming has been recognized as a good practice for efficiently exploiting parallel hardware resources. Following this approach, multiple libraries have been designed for providing such high-level abstractions to ease the parallel programming. However, those libraries do not share a common interface. To pave the way, GrPPI has been designed for providing an intermediate abstraction layer between application developers and existing parallel programming frameworks like OpenMP, Intel TBB or ISO C++ threads. On the other hand, FastFlow has been adopted as an efficient object-based programming framework that may benefit from being supported as an additional GrPPI backend. However, the object-based approach presents some major challenges to be incorporated under the GrPPI type safe functional programming style. In this paper, we present the integration of FastFlow as a new GrPPI backend to demonstrate that structured parallel programming frameworks perfectly fit the GrPPI design. Additionally, we also demonstrate that GrPPI does not incur in additional overheads for providing its abstraction layer, and we study the programmability in terms of lines of code and cyclomatic complexity. In general, the presented work acts as reciprocal validation of both FastFlow (as an efficient, native structured parallel programming framework) and GrPPI (as an efficient abstraction layer on top of existing parallel programming frameworks).},
author = {Garcia, Jose Daniel and del Rio, Jose Daniel and Marco Aldinucci and Fabio Tordini and Marco Danelutto and Gabriele Mencagli and Massimo Torquati},
date-modified = {2020-11-15 19:15:18 +0100},
doi = {10.1007/s11227-019-02826-5},
journal = {The Journal of Supercomputing},
keywords = {rephrase, fastflow},
number = {7},
pages = {5139-5159},
title = {Challenging the abstraction penalty in parallel patterns libraries: Adding FastFlow support to GrPPI},
url = {https://iris.unito.it/retrieve/handle/2318/1762686/744894/2020-js-grppi-postprint.pdf},
volume = {76},
year = {2020},
bdsk-url-1 = {https://doi.org/10.1007/s11227-019-02826-5}
}

• V. Amaral, B. Norberto, M. Goulão, M. Aldinucci, S. Benkner, A. Bracciali, P. Carreira, E. Celms, L. ‘i, C. Grelck, H. Karatza, C. Kessler, P. Kilpatrick, H. Martiniano, I. Mavridis, S. Pllana, A. R. ‘i, J. Simão, L. ‘i, and A. Visa, “Programming languages for data-intensive hpc applications: a systematic mapping study,” Parallel computing, p. 102584, 2020. doi:https://doi.org/10.1016/j.parco.2019.102584

A major challenge in modelling and simulation is the need to combine expertise in both software technologies and a given scientific domain. When High-Performance Computing (HPC) is required to solve a scientific problem, software development becomes a problematic issue. Considering the complexity of the software for HPC, it is useful to identify programming languages that can be used to alleviate this issue. Because the existing literature on the topic of HPC is very dispersed, we performed a Systematic Mapping Study (SMS) in the context of the European COST Action cHiPSet. This literature study maps characteristics of various programming languages for data-intensive HPC applications, including category, typical user profiles, effectiveness, and type of articles. We organised the SMS in two phases. In the first phase, relevant articles are identified employing an automated keyword-based search in eight digital libraries. This lead to an initial sample of 420 papers, which was then narrowed down in a second phase by human inspection of article abstracts, titles and keywords to 152 relevant articles published in the period 2006–2018. The analysis of these articles enabled us to identify 26 programming languages referred to in 33 of relevant articles. We compared the outcome of the mapping study with results of our questionnaire-based survey that involved 57 HPC experts. The mapping study and the survey revealed that the desired features of programming languages for data-intensive HPC applications are portability, performance and usability. Furthermore, we observed that the majority of the programming languages used in the context of data-intensive HPC applications are text-based general-purpose programming languages. Typically these have a steep learning curve, which makes them difficult to adopt. We believe that the outcome of this study will inspire future research and development in programming languages for data-intensive HPC applications.

@article{20:sms:chipset,
abstract = {A major challenge in modelling and simulation is the need to combine expertise in both software technologies and a given scientific domain. When High-Performance Computing (HPC) is required to solve a scientific problem, software development becomes a problematic issue. Considering the complexity of the software for HPC, it is useful to identify programming languages that can be used to alleviate this issue. Because the existing literature on the topic of HPC is very dispersed, we performed a Systematic Mapping Study (SMS) in the context of the European COST Action cHiPSet. This literature study maps characteristics of various programming languages for data-intensive HPC applications, including category, typical user profiles, effectiveness, and type of articles. We organised the SMS in two phases. In the first phase, relevant articles are identified employing an automated keyword-based search in eight digital libraries. This lead to an initial sample of 420 papers, which was then narrowed down in a second phase by human inspection of article abstracts, titles and keywords to 152 relevant articles published in the period 2006--2018. The analysis of these articles enabled us to identify 26 programming languages referred to in 33 of relevant articles. We compared the outcome of the mapping study with results of our questionnaire-based survey that involved 57 HPC experts. The mapping study and the survey revealed that the desired features of programming languages for data-intensive HPC applications are portability, performance and usability. Furthermore, we observed that the majority of the programming languages used in the context of data-intensive HPC applications are text-based general-purpose programming languages. Typically these have a steep learning curve, which makes them difficult to adopt. We believe that the outcome of this study will inspire future research and development in programming languages for data-intensive HPC applications.},
author = {Vasco Amaral and Beatriz Norberto and Miguel Goul{\~a}o and Marco Aldinucci and Siegfried Benkner and Andrea Bracciali and Paulo Carreira and Edgars Celms and Lu{\'\i}s Correia and Clemens Grelck and Helen Karatza and Christoph Kessler and Peter Kilpatrick and Hugo Martiniano and Ilias Mavridis and Sabri Pllana and Ana Resp{\'\i}cio and Jos{\'e} Sim{\~a}o and Lu{\'\i}s Veiga and Ari Visa},
date-modified = {2020-11-15 17:21:48 +0100},
doi = {https://doi.org/10.1016/j.parco.2019.102584},
issn = {0167-8191},
journal = {Parallel Computing},
keywords = {HPC, bigdata, chipset},
pages = {102584},
title = {Programming languages for data-Intensive HPC applications: A systematic mapping study},
url = {https://iris.unito.it/retrieve/689605/1-s2.0-S0167819119301759-main.pdf},
year = {2020},
bdsk-url-1 = {http://www.sciencedirect.com/science/article/pii/S0167819119301759},
bdsk-url-2 = {https://doi.org/10.1016/j.parco.2019.102584}
}

• D. D’Agostino, P. Liò, M. Aldinucci, and I. Merelli, “NeoHiC: a web application for the analysis of Hi-C data,” in Lecture notes in computer science (including subseries lecture notes in artificial intelligence and lecture notes in bioinformatics), 2020, pp. 98-107. doi:10.1007/978-3-030-63061-4_10

High-throughput sequencing Chromosome Conformation Capture (Hi-C) allows the study of chromatin interactions and 3D chromosome folding on a larger scale. A graph-based multi-level representation of Hi-C data is essential for proper visualisation of the spatial pattern they represent, in particular for comparing different experiments or for re-mapping omics-data in a space-aware context. The size of the HiC data hampers the straightforward use of currently available graph visualisation tools and libraries. In this paper, we present the first version of NeoHiC, a user-friendly web application for the progressive graph visualisation of Hi-C data based on the use of the Neo4j graph database. The user could select the richness of the environment of the query gene by choosing among a large number of proximity and distance metrics.

@inproceedings{20:neohic:cibb,
abstract = {High-throughput sequencing Chromosome Conformation Capture (Hi-C) allows the study of chromatin interactions and 3D chromosome folding on a larger scale. A graph-based multi-level representation of Hi-C data is essential for proper visualisation of the spatial pattern they represent, in particular for comparing different experiments or for re-mapping omics-data in a space-aware context. The size of the HiC data hampers the straightforward use of currently available graph visualisation tools and libraries. In this paper, we present the first version of NeoHiC, a user-friendly web application for the progressive graph visualisation of Hi-C data based on the use of the Neo4j graph database. The user could select the richness of the environment of the query gene by choosing among a large number of proximity and distance metrics.},
author = {Daniele D'Agostino and Pietro Li{\o} and Marco Aldinucci and Ivan Merelli},
booktitle = {Lecture Notes in Computer Science (including subseries Lecture Notes in Artificial Intelligence and Lecture Notes in Bioinformatics)},
date-modified = {2021-01-07 10:59:27 +0100},
doi = {10.1007/978-3-030-63061-4_10},
isbn = {978-3-030-63061-4},
pages = {98-107},
title = {{NeoHiC}: A web application for the analysis of {Hi-C} data},
url = {https://iris.unito.it/retrieve/handle/2318/1766001/690791/20_neohic_cibb.pdf},
volume = {12313},
year = {2020},
bdsk-url-1 = {https://iris.unito.it/retrieve/handle/2318/1766001/690791/20_neohic_cibb.pdf},
bdsk-url-2 = {https://doi.org/10.1007/978-3-030-63061-4_10}
}

### 2019

• M. Aldinucci, S. Bagnasco, M. Concas, S. Lusso, S. Rabellino, D. Demarchi, and S. Vallero, “Managing a heterogeneous scientific computing cluster with cloud-like tools: ideas and experience,” in European physical journal web of conferences, 2019, p. 7030. doi:10.1051/epjconf/201921407030

Obtaining CPU cycles on an HPC cluster is nowadays relatively simple and sometimes even cheap for academic institutions. However, in most of the cases providers of HPC services would not allow changes on the configuration, implementation of special features or a lower-level control on the computing infrastructure, for example for testing experimental configurations. The variety of use cases proposed by several departments of the University of Torino, including ones from solid-state chemistry, computational biology, genomics and many others, called for different and sometimes conflicting configurations; furthermore, several R&D activities in the field of scientific computing, with topics ranging from GPU acceleration to Cloud Computing technologies, needed a platform to be carried out on. The Open Computing Cluster for Advanced data Manipulation (OCCAM) is a multi-purpose flexible HPC cluster designed and operated by a collaboration between the University of Torino and the Torino branch of the Istituto Nazionale di Fisica Nucleare. It is aimed at providing a flexible and reconfigurable infrastructure to cater to a wide range of different scientific computing needs, as well as a platform for R&D activities on computational technologies themselves. We describe some of the use cases that prompted the design and construction of the system, its architecture and a first characterisation of its performance by some synthetic benchmark tools and a few realistic use-case tests.

@inproceedings{2019EPJWC.21407030A,
abstract = {Obtaining CPU cycles on an HPC cluster is nowadays relatively simple and sometimes even cheap for academic institutions. However, in most of the cases providers of HPC services would not allow changes on the configuration, implementation of special features or a lower-level control on the computing infrastructure, for example for testing experimental configurations. The variety of use cases proposed by several departments of the University of Torino, including ones from solid-state chemistry, computational biology, genomics and many others, called for different and sometimes conflicting configurations; furthermore, several R&D activities in the field of scientific computing, with topics ranging from GPU acceleration to Cloud Computing technologies, needed a platform to be carried out on. The Open Computing Cluster for Advanced data Manipulation (OCCAM) is a multi-purpose flexible HPC cluster designed and operated by a collaboration between the University of Torino and the Torino branch of the Istituto Nazionale di Fisica Nucleare. It is aimed at providing a flexible and reconfigurable infrastructure to cater to a wide range of different scientific computing needs, as well as a platform for R&D activities on computational technologies themselves. We describe some of the use cases that prompted the design and construction of the system, its architecture and a first characterisation of its performance by some synthetic benchmark tools and a few realistic use-case tests.},
adsnote = {Provided by the SAO/NASA Astrophysics Data System},
author = {Aldinucci, Marco and Bagnasco, Stefano and Concas, Matteo and Lusso, Stefano and Rabellino, Sergio and Demarchi, Danilo and Vallero, Sara},
booktitle = {European Physical Journal Web of Conferences},
doi = {10.1051/epjconf/201921407030},
eid = {07030},
month = {Jul},
pages = {07030},
series = {European Physical Journal Web of Conferences},
title = {{Managing a heterogeneous scientific computing cluster with cloud-like tools: ideas and experience}},
url = {https://iris.unito.it/retrieve/533279/epjconf_chep2018_07030.pdf},
volume = {214},
year = {2019},
bdsk-url-1 = {https://iris.unito.it/retrieve/533279/epjconf_chep2018_07030.pdf},
bdsk-url-2 = {https://doi.org/10.1051/epjconf/201921407030}
}

• P. Viviani, M. Drocco, D. Baccega, I. Colonnelli, and M. Aldinucci, “Deep learning at scale,” in Proc. of 27th euromicro intl. conference on parallel distributed and network-based processing (pdp), Pavia, Italy, 2019, pp. 124-131. doi:10.1109/EMPDP.2019.8671552

This work presents a novel approach to distributed training of deep neural networks (DNNs) that aims to overcome the issues related to mainstream approaches to data parallel training. Established techniques for data parallel training are discussed from both a parallel computing and deep learning perspective, then a different approach is presented that is meant to allow DNN training to scale while retaining good convergence properties. Moreover, an experimental implementation is presented as well as some preliminary results.

@inproceedings{19:deeplearn:pdp,
abstract = {This work presents a novel approach to distributed training of deep neural networks (DNNs) that aims to overcome the issues related to mainstream approaches to data parallel training. Established techniques for data parallel training are discussed from both a parallel computing and deep learning perspective, then a different approach is presented that is meant to allow DNN training to scale while retaining good convergence properties. Moreover, an experimental implementation is presented as well as some preliminary results.},
author = {Paolo Viviani and Maurizio Drocco and Daniele Baccega and Iacopo Colonnelli and Marco Aldinucci},
booktitle = {Proc. of 27th Euromicro Intl. Conference on Parallel Distributed and network-based Processing (PDP)},
date-modified = {2020-11-15 15:00:34 +0100},
doi = {10.1109/EMPDP.2019.8671552},
keywords = {machine learning},
pages = {124-131},
publisher = {IEEE},
title = {Deep Learning at Scale},
url = {https://iris.unito.it/retrieve/handle/2318/1695211/487778/19_deeplearning_PDP.pdf},
year = {2019},
bdsk-url-1 = {https://iris.unito.it/retrieve/handle/2318/1695211/487778/19_deeplearning_PDP.pdf},
bdsk-url-2 = {https://doi.org/10.1109/EMPDP.2019.8671552}
}

• I. Merelli, F. Fornari, F. Tordini, D. D’Agostino, M. Aldinucci, and D. Cesini, “Exploiting docker containers over grid computing for a comprehensive study of chromatin conformation in different cell types,” Journal of parallel and distributed computing, vol. 134, pp. 116-127, 2019. doi:10.1016/j.jpdc.2019.08.002

Many bioinformatic applications require to exploit the capabilities of several computational resources to effectively access and process large and distributed datasets. In this context, Grid computing has been largely used to face unprecedented challenges in Computational Biology, at the cost of complex workarounds needed to make applications successfully running. The Grid computing paradigm, in fact, has always suffered from a lack of flexibility. Although this has been partially solved by Cloud computing, the on-demand approach is way distant from the original idea of volunteering computing that boosted the Grid paradigm. A solution to outpace the impossibility of creating custom environments for running applications in Grid is represented by the containerization technology. In this paper, we describe our experience in exploiting a Docker-based approach to run in a Grid environment a novel, computationally intensive, bioinformatic application, which models the DNA spatial conformation inside the nucleus of eukaryotic cells. Results assess the feasibility of this approach in terms of performance and efforts to run large experiments.

@article{19:merelli:jpdc,
abstract = {Many bioinformatic applications require to exploit the capabilities of several computational resources to effectively access and process large and distributed datasets. In this context, Grid computing has been largely used to face unprecedented challenges in Computational Biology, at the cost of complex workarounds needed to make applications successfully running. The Grid computing paradigm, in fact, has always suffered from a lack of flexibility. Although this has been partially solved by Cloud computing, the on-demand approach is way distant from the original idea of volunteering computing that boosted the Grid paradigm. A solution to outpace the impossibility of creating custom environments for running applications in Grid is represented by the containerization technology. In this paper, we describe our experience in exploiting a Docker-based approach to run in a Grid environment a novel, computationally intensive, bioinformatic application, which models the DNA spatial conformation inside the nucleus of eukaryotic cells. Results assess the feasibility of this approach in terms of performance and efforts to run large experiments.},
author = {Ivan Merelli and Federico Fornari and Fabio Tordini and Daniele D'Agostino and Marco Aldinucci and Daniele Cesini},
date-modified = {2019-09-04 15:25:57 +0200},
doi = {10.1016/j.jpdc.2019.08.002},
issn = {0743-7315},
journal = {Journal of Parallel and Distributed Computing},
keywords = {bioinformatics},
pages = {116 - 127},
title = {Exploiting Docker containers over Grid computing for a comprehensive study of chromatin conformation in different cell types},
url = {https://iris.unito.it/retrieve/handle/2318/1711684/532767/2019_Nuchart_JPDC_open.pdf},
volume = {134},
year = {2019},
bdsk-url-1 = {https://iris.unito.it/retrieve/handle/2318/1711684/532767/2019_Nuchart_JPDC_open.pdf},
bdsk-url-2 = {https://doi.org/10.1016/j.jpdc.2019.08.002}
}

• M. Aldinucci, C. Berzovini, C. Grana, M. Grangetto, L. Pireddu, and G. Zanetti, Deep learning e calcolo ad alte prestazioni per l’elaborazione di immagini biomediche, 2019.
[BibTeX] [Abstract]

Il progetto DeepHealth, recentemente finanziato dalla Commissione Europea, ha come obiettivo la realizzazione di un ecosistema europeo costituito da piattaforme di calcolo ad alte prestazioni, librerie software e competenze multi-disciplinari di intelligenza artificiale, calcolo parallelo e scienze mediche per l’elaborazione e la diagnosi basata su immagini. Il contributo presenta sinteticamente le competenze e le infrastrutture nazionali coinvolte nel progetto.

@misc{19:italia,
abstract = {Il progetto DeepHealth, recentemente finanziato dalla Commissione Europea, ha come obiettivo la realizzazione di un ecosistema europeo costituito da piattaforme di calcolo ad alte prestazioni, librerie software e competenze multi-disciplinari di intelligenza artificiale, calcolo parallelo e scienze mediche per l'elaborazione e la diagnosi basata su immagini. Il contributo presenta sinteticamente le competenze e le infrastrutture nazionali coinvolte nel progetto.
},
author = {Marco Aldinucci and Claudio Berzovini and Costantino Grana and Marco Grangetto and Luca Pireddu and Gianluigi Zanetti},
date-modified = {2021-03-27 00:03:43 +0100},
howpublished = {{Ital-IA}: Convegno Nazionale CINI sull'Intelligenza Artificiale},
keywords = {hpc4ai},
month = mar,
title = {Deep Learning e calcolo ad alte prestazioni per l'elaborazione di immagini biomediche},
year = {2019}
}

• C. Grelck, E. Niewiadomska-Szynkiewicz, M. Aldinucci, A. Bracciali, and E. Larsson, “Why high-performance modelling and simulation for big data applications matters,” in High-performance modelling and simulation for big data applications: selected results of the cost action ic1406 chipset, J. Ko{l}odziej and H. González-Vélez, Eds., Cham: Springer international publishing, 2019, p. 1–35. doi:10.1007/978-3-030-16272-6_1

Modelling and Simulation (M{&}S) offer adequate abstractions to manage the complexity of analysing big data in scientific and engineering domains. Unfortunately, big data problems are often not easily amenable to efficient and effective use of High Performance Computing (HPC) facilities and technologies. Furthermore, M{&}S communities typically lack the detailed expertise required to exploit the full potential of HPC solutions while HPC specialists may not be fully aware of specific modelling and simulation requirements and applications.

@inbook{Grelck2019,
abstract = {Modelling and Simulation (M{\&}S) offer adequate abstractions to manage the complexity of analysing big data in scientific and engineering domains. Unfortunately, big data problems are often not easily amenable to efficient and effective use of High Performance Computing (HPC) facilities and technologies. Furthermore, M{\&}S communities typically lack the detailed expertise required to exploit the full potential of HPC solutions while HPC specialists may not be fully aware of specific modelling and simulation requirements and applications.},
author = {Grelck, Clemens and Niewiadomska-Szynkiewicz, Ewa and Aldinucci, Marco and Bracciali, Andrea and Larsson, Elisabeth},
booktitle = {High-Performance Modelling and Simulation for Big Data Applications: Selected Results of the COST Action IC1406 cHiPSet},
date-modified = {2019-03-25 23:09:42 +0100},
doi = {10.1007/978-3-030-16272-6_1},
editor = {Ko{\l}odziej, Joanna and Gonz{\'a}lez-V{\'e}lez, Horacio},
isbn = {978-3-030-16272-6},
keywords = {chipset},
number = {11400},
pages = {1--35},
publisher = {Springer International Publishing},
series = {LNCS},
title = {Why High-Performance Modelling and Simulation for Big Data Applications Matters},
year = {2019},
bdsk-url-2 = {https://doi.org/10.1007/978-3-030-16272-6_1}
}

• M. Drocco, P. Viviani, I. Colonnelli, M. Aldinucci, and M. Grangetto, “Accelerating spectral graph analysis through wavefronts of linear algebra operations,” in Proc. of 27th euromicro intl. conference on parallel distributed and network-based processing (pdp), Pavia, Italy, 2019, pp. 9-16. doi:10.1109/EMPDP.2019.8671640

The wavefront pattern captures the unfolding of a parallel computation in which data elements are laid out as a logical multidimensional grid and the dependency graph favours a diagonal sweep across the grid. In the emerging area of spectral graph analysis, the computing often consists in a wavefront running over a tiled matrix, involving expensive linear algebra kernels. While these applications might benefit from parallel heterogeneous platforms (multi-core with GPUs),programming wavefront applications directly with high-performance linear algebra libraries yields code that is complex to write and optimize for the specific application. We advocate a methodology based on two abstractions (linear algebra and parallel pattern-based run-time), that allows to develop portable, self-configuring, and easy-to-profile code on hybrid platforms.

@inproceedings{19:gsp:pdp,
abstract = {The wavefront pattern captures the unfolding of a parallel computation in which data elements are laid out as a logical multidimensional grid and the dependency graph favours a diagonal sweep across the grid. In the emerging area of spectral graph analysis, the computing often consists in a wavefront running over a tiled matrix, involving expensive linear algebra kernels. While these applications might benefit from parallel heterogeneous platforms (multi-core with GPUs),programming wavefront applications directly with high-performance linear algebra libraries yields code that is complex to write and optimize for the specific application. We advocate a methodology based on two abstractions (linear algebra and parallel pattern-based run-time), that allows to develop portable, self-configuring, and easy-to-profile code on hybrid platforms.},
author = {Maurizio Drocco and Paolo Viviani and Iacopo Colonnelli and Marco Aldinucci and Marco Grangetto},
booktitle = {Proc. of 27th Euromicro Intl. Conference on Parallel Distributed and network-based Processing (PDP)},
date-modified = {2021-04-24 23:22:22 +0200},
doi = {10.1109/EMPDP.2019.8671640},
pages = {9-16},
publisher = {IEEE},
title = {Accelerating spectral graph analysis through wavefronts of linear algebra operations},
url = {https://iris.unito.it/retrieve/handle/2318/1695315/488105/19_wavefront_PDP.pdf},
year = {2019},
bdsk-url-1 = {https://iris.unito.it/retrieve/handle/2318/1695315/488105/19_wavefront_PDP.pdf},
bdsk-url-2 = {https://doi.org/10.1109/EMPDP.2019.8671640}
}

• M. Torquati, D. De Sensi, G. Mencagli, M. Aldinucci, and M. Danelutto, “Power-aware pipelining with automatic concurrency control,” Concurrency and computation: practice and experience, vol. 31, iss. 5, 2019. doi:10.1002/cpe.4652

Continuous streaming computations are usually composed of different modules, exchanging data through shared message queues. The selection of the algorithm used to access such queues (i.e. the concurrency control) is a critical aspect both for performance and power consumption. In this paper we describe the design of automatic concurrency control algorithm for implement- ing power-efficient communications on shared-memory multicores. The algorithm automatically switches between nonblocking and blocking concurrency protocols, getting the best from the two worlds, i.e. obtaining the same throughput offered by the nonblocking implementa- tion and the same power efficiency of the blocking concurrency protocol. We demonstrate the effectiveness of our approach using two micro-benchmarks and two real streaming applications

@article{18:dynqueue:ccpe,
abstract = {Continuous streaming computations are usually composed of different modules, exchanging data through shared message queues. The selection of the algorithm used to access such queues (i.e. the concurrency control) is a critical aspect both for performance and power consumption. In this paper we describe the design of automatic concurrency control algorithm for implement- ing power-efficient communications on shared-memory multicores. The algorithm automatically switches between nonblocking and blocking concurrency protocols, getting the best from the two worlds, i.e. obtaining the same throughput offered by the nonblocking implementa- tion and the same power efficiency of the blocking concurrency protocol. We demonstrate the effectiveness of our approach using two micro-benchmarks and two real streaming applications},
author = {Massimo Torquati and De Sensi, Daniele and Gabriele Mencagli and Marco Aldinucci and Marco Danelutto},
date-modified = {2019-03-22 23:49:37 +0100},
doi = {10.1002/cpe.4652},
journal = {Concurrency and Computation: Practice and Experience},
keywords = {rephrase},
number = {5},
title = {Power-Aware Pipelining with Automatic Concurrency Control},
url = {https://iris.unito.it/retrieve/handle/2318/1668445/414282/2018_CCPE.pdf},
volume = {31},
year = {2019},
bdsk-url-1 = {https://iris.unito.it/retrieve/handle/2318/1668445/414282/2018_CCPE.pdf},
bdsk-url-2 = {https://doi.org/10.1002/cpe.4652}
}

• M. Aldinucci, M. Drocco, C. Misale, and G. Tremblay, “Languages for big data analysis,” in Encyclopedia of big data technologies, S. Sakr and A. Zomaya, Eds., Cham: Springer international publishing, 2019. doi:10.1007/978-3-319-63962-8_142-1

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.

@inbook{bigdata:encyclopedia:18,
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.},
author = {Aldinucci, Marco and Drocco, Maurizio and Misale, Claudia and Tremblay, Guy},
booktitle = {Encyclopedia of Big Data Technologies},
date-modified = {2019-03-22 08:13:33 +0100},
doi = {10.1007/978-3-319-63962-8_142-1},
editor = {Sakr, Sherif and Zomaya, Albert},
isbn = {978-3-319-63962-8},
publisher = {Springer International Publishing},
title = {Languages for Big Data analysis},
url = {https://iris.unito.it/retrieve/handle/2318/1668051/413363/2019_bigdataframeworks_enc.pdf},
year = {2019},
bdsk-url-1 = {https://iris.unito.it/retrieve/handle/2318/1668051/413363/2019_bigdataframeworks_enc.pdf},
bdsk-url-2 = {https://doi.org/10.1007/978-3-319-63962-8_142-1}
}

• M. Danelutto, T. De Matteis, D. De Sensi, G. Mencagli, M. Torquati, M. Aldinucci, and P. Kilpatrick, “The rephrase extended pattern set for data intensive parallel computing,” International journal of parallel programming, vol. 47, iss. 1, pp. 74-93, 2019. doi:10.1007/s10766-017-0540-z

We discuss the extended parallel pattern set identified within the EU-funded project RePhrase as a candidate pattern set to support data intensive applications targeting heterogeneous architectures. The set has been designed to include three classes of pattern, namely i) core patterns, modelling common, not necessarily data intensive parallelism exploitation patterns, usually to be used in composition; ii) high level patterns, modelling common, complex and complete parallelism exploitation patterns; and iii) building block patterns, modelling the single components of data intensive applications, suitable for use–in composition–to implement patterns not covered by the core and high level patterns. We discuss the expressive power of the RePhrase extended pattern set and results illustrating the performances that may be achieved with the FastFlow implementation of the high level patterns.

@article{17:rephrasepatterns:ijpp,
abstract = {We discuss the extended parallel pattern set identified within the EU-funded project RePhrase as a candidate pattern set to support data intensive applications targeting heterogeneous architectures. The set has been designed to include three classes of pattern, namely i) core patterns, modelling common, not necessarily data intensive parallelism exploitation patterns, usually to be used in composition; ii) high level patterns, modelling common, complex and complete parallelism exploitation patterns; and iii) building block patterns, modelling the single components of data intensive applications, suitable for use--in composition--to implement patterns not covered by the core and high level patterns. We discuss the expressive power of the RePhrase extended pattern set and results illustrating the performances that may be achieved with the FastFlow implementation of the high level patterns.},
author = {Marco Danelutto and De Matteis, Tiziano and De Sensi, Daniele and Gabriele Mencagli and Massimo Torquati and Marco Aldinucci and Peter Kilpatrick},
date-modified = {2019-03-22 23:49:02 +0100},
doi = {10.1007/s10766-017-0540-z},
journal = {International Journal of Parallel Programming},
keywords = {rephrase, fastflow},
number = {1},
pages = {74-93},
title = {The RePhrase Extended Pattern Set for Data Intensive Parallel Computing},
url = {https://iris.unito.it/retrieve/handle/2318/1659336/387667/2017_ijpp_rephrase.pdf},
volume = {47},
year = {2019},
bdsk-url-1 = {https://iris.unito.it/retrieve/handle/2318/1659336/387667/2017_ijpp_rephrase.pdf},
bdsk-url-2 = {https://doi.org/10.1007/s10766-017-0540-z}
}

• M. Torquati, G. Mencagli, M. Drocco, M. Aldinucci, T. De Matteis, and M. Danelutto, “On dynamic memory allocation in sliding-window parallel patterns for streaming analytics,” The journal of supercomputing, vol. 75, iss. 8, p. 4114–4131, 2019. doi:10.1007/s11227-017-2152-1

This work studies the issues related to dynamic memory management in Data Stream Processing, an emerging paradigm enabling the real-time processing of live data streams. In this paper we consider two streaming parallel patterns and we discuss different implementation variants related on how dynamic memory is managed. The results show that the standard mechanisms provided by modern C++ are not entirely adequate for maximizing the performance. Instead, the combined use of an efficient general-purpose memory allocator, a custom allocator optimized for the pattern considered and a custom variant of the C++ shared pointer mechanism, provides a performance improvement up to 16{\%} on the best case.

@article{17:dmadasp:jsupe,
abstract = {This work studies the issues related to dynamic memory management in Data Stream Processing, an emerging paradigm enabling the real-time processing of live data streams. In this paper we consider two streaming parallel patterns and we discuss different implementation variants related on how dynamic memory is managed. The results show that the standard mechanisms provided by modern C++ are not entirely adequate for maximizing the performance. Instead, the combined use of an efficient general-purpose memory allocator, a custom allocator optimized for the pattern considered and a custom variant of the C++ shared pointer mechanism, provides a performance improvement up to 16{\%} on the best case.},
author = {Massimo Torquati and Gabriele Mencagli and Maurizio Drocco and Marco Aldinucci and De Matteis, Tiziano and Marco Danelutto},
doi = {10.1007/s11227-017-2152-1},
journal = {The Journal of Supercomputing},
keywords = {rephrase, fastflow},
number = {8},
pages = {4114--4131},
title = {On Dynamic Memory Allocation in Sliding-Window Parallel Patterns for Streaming Analytics},
url = {https://iris.unito.it/retrieve/handle/2318/1648626/362381/17_torquati_jsc.pdf},
volume = {75},
year = 2019,
bdsk-url-1 = {https://iris.unito.it/retrieve/handle/2318/1648626/362381/17_torquati_jsc.pdf},
bdsk-url-2 = {https://doi.org/10.1007/s11227-017-2152-1}
}

### 2018

• C. Misale, M. Drocco, G. Tremblay, and M. Aldinucci, “Pico: a novel approach to stream data analytics,” in Proc. of euro-par workshops: 1st intl. workshop on autonomic solutions for parallel and distributed data stream processing (auto-dasp 2017), Santiago de Compostela, Spain, 2018. doi:10.1007/978-3-319-75178-8_10

In this paper, we present a new C++ API with a fluent interface called PiCo (Pipeline Composition). PiCo’s programming model aims at making easier the programming of data analytics applications while preserving or enhancing their performance. This is attained through three key design choices: 1) unifying batch and stream data access models, 2) decoupling processing from data layout, and 3) exploiting a stream-oriented, scalable, effiicient C++11 runtime system. PiCo proposes a programming model based on pipelines and operators that are polymorphic with respect to data types in the sense that it is possible to re-use the same algorithms and pipelines on different data models (e.g., streams, lists, sets, etc.). Preliminary results show that PiCo can attain better performances in terms of execution times and hugely improve memory utilization when compared to Spark and Flink in both batch and stream processing.

@inproceedings{pico:autodasp:17,
abstract = {In this paper, we present a new C++ API with a fluent interface called PiCo (Pipeline Composition). PiCo's programming model aims at making easier the programming of data analytics applications while preserving or enhancing their performance. This is attained through three key design choices: 1) unifying batch and stream data access models, 2) decoupling processing from data layout, and 3) exploiting a stream-oriented, scalable, effiicient C++11 runtime system. PiCo proposes a programming model based on pipelines and operators that are polymorphic with respect to data types in the sense that it is possible to re-use the same algorithms and pipelines on different data models (e.g., streams, lists, sets, etc.). Preliminary results show that PiCo can attain better performances in terms of execution times and hugely improve memory utilization when compared to Spark and Flink in both batch and stream processing.},
address = {Santiago de Compostela, Spain},
author = {Claudia Misale and Maurizio Drocco and Guy Tremblay and Marco Aldinucci},
booktitle = {Proc. of Euro-Par Workshops: 1st Intl. Workshop on Autonomic Solutions for Parallel and Distributed Data Stream Processing (Auto-DaSP 2017)},
date-modified = {2018-01-21 16:08:28 +0000},
doi = {10.1007/978-3-319-75178-8_10},
month = aug,
publisher = {Springer},
series = {{LNCS}},
title = {PiCo: a Novel Approach to Stream Data Analytics},
url = {https://iris.unito.it/retrieve/handle/2318/1659344/409520/autodasp.pdf},
volume = {10659},
year = {2018},
bdsk-url-1 = {https://dx.doi.org/10.1007/978-3-319-75178-8_10},
bdsk-url-2 = {https://iris.unito.it/retrieve/handle/2318/1659344/409520/autodasp.pdf}
}

• G. Mencagli, M. Torquati, F. Lucattini, S. Cuomo, and M. Aldinucci, “Harnessing sliding-window execution semantics for parallel stream processing,” Journal of parallel and distributed computing, vol. 116, pp. 74-88, 2018. doi:10.1016/j.jpdc.2017.10.021

Abstract According to the recent trend in data acquisition and processing technology, big data are increasingly available in the form of unbounded streams of elementary data items to be processed in real-time. In this paper we study in detail the paradigm of sliding windows, a well-known technique for approximated queries that update their results continuously as new fresh data arrive from the stream. In this work we focus on the relationship between the various existing sliding window semantics and the way the query processing is performed from the parallelism perspective. From this study two alternative parallel models are identified, each covering semantics with very precise properties. Each model is described in terms of its pros and cons, and parallel implementations in the FastFlow framework are analyzed by discussing the layout of the concurrent data structures used for the efficient windows representation in each model.

@article{17:slidingwindows:jpdc,
abstract = {Abstract According to the recent trend in data acquisition and processing technology, big data are increasingly available in the form of unbounded streams of elementary data items to be processed in real-time. In this paper we study in detail the paradigm of sliding windows, a well-known technique for approximated queries that update their results continuously as new fresh data arrive from the stream. In this work we focus on the relationship between the various existing sliding window semantics and the way the query processing is performed from the parallelism perspective. From this study two alternative parallel models are identified, each covering semantics with very precise properties. Each model is described in terms of its pros and cons, and parallel implementations in the FastFlow framework are analyzed by discussing the layout of the concurrent data structures used for the efficient windows representation in each model. },
author = {Gabriele Mencagli and Massimo Torquati and Fabio Lucattini and Salvatore Cuomo and Marco Aldinucci},
date-modified = {2018-12-27 18:24:34 +0100},
doi = {10.1016/j.jpdc.2017.10.021},
issn = {0743-7315},
journal = {Journal of Parallel and Distributed Computing},
keywords = {rephrase, fastflow},
month = jun,
pages = {74-88},
title = {Harnessing sliding-window execution semantics for parallel stream processing},
url = {https://aperto.unito.it/retrieve/handle/2318/1653126/373095/preprint-jpdc-2017.pdf},
volume = {116},
year = {2018},
bdsk-url-1 = {https://iris.unito.it/retrieve/handle/2318/1653126/373085/preprint-jpdc-2017.pdf},
bdsk-url-2 = {http://dx.doi.org/10.1016/j.jpdc.2017.10.021},
bdsk-url-3 = {https://aperto.unito.it/retrieve/handle/2318/1653126/373095/preprint-jpdc-2017.pdf}
}

• M. Aldinucci, S. Rabellino, M. Pironti, F. Spiga, P. Viviani, M. Drocco, M. Guerzoni, G. Boella, M. Mellia, P. Margara, I. Drago, R. Marturano, G. Marchetto, E. Piccolo, S. Bagnasco, S. Lusso, S. Vallero, G. Attardi, A. Barchiesi, A. Colla, and F. Galeazzi, “HPC4AI, an AI-on-demand federated platform endeavour,” in Acm computing frontiers, Ischia, Italy, 2018. doi:10.1145/3203217.3205340

In April 2018, under the auspices of the POR-FESR 2014-2020 program of Italian Piedmont Region, the Turin’s Centre on High-Performance Computing for Artificial Intelligence (HPC4AI) was funded with a capital investment of 4.5Me and it began its deployment. HPC4AI aims to facilitate scientific research and engineering in the areas of Artificial Intelligence and Big Data Analytics. HPC4AI will specifically focus on methods for the on-demand provisioning of AI and BDA Cloud services to the regional and national industrial community, which includes the large regional ecosystem of Small-Medium Enterprises (SMEs) active in many different sectors such as automotive, aerospace, mechatronics, manufacturing, health and agrifood.

@inproceedings{18:hpc4ai_acm_CF,
abstract = {In April 2018, under the auspices of the POR-FESR 2014-2020 program of Italian Piedmont Region, the Turin's Centre on High-Performance Computing for Artificial Intelligence (HPC4AI) was funded with a capital investment of 4.5Me and it began its deployment. HPC4AI aims to facilitate scientific research and engineering in the areas of Artificial Intelligence and Big Data Analytics. HPC4AI will specifically focus on methods for the on-demand provisioning of AI and BDA Cloud services to the regional and national industrial community, which includes the large regional ecosystem of Small-Medium Enterprises (SMEs) active in many different sectors such as automotive, aerospace, mechatronics, manufacturing, health and agrifood.
},
author = {Marco Aldinucci and Sergio Rabellino and Marco Pironti and Filippo Spiga and Paolo Viviani and Maurizio Drocco and Marco Guerzoni and Guido Boella and Marco Mellia and Paolo Margara and Idillio Drago and Roberto Marturano and Guido Marchetto and Elio Piccolo and Stefano Bagnasco and Stefano Lusso and Sara Vallero and Giuseppe Attardi and Alex Barchiesi and Alberto Colla and Fulvio Galeazzi},
booktitle = {ACM Computing Frontiers},
date-modified = {2018-12-17 23:57:55 +0100},
doi = {10.1145/3203217.3205340},
month = may,
title = {{HPC4AI}, an {AI-on-demand} federated platform endeavour},
url = {https://iris.unito.it/retrieve/handle/2318/1765596/689772/2018_hpc4ai_ACM_CF.pdf},
year = {2018},
bdsk-url-1 = {https://iris.unito.it/retrieve/handle/2318/1765596/689772/2018_hpc4ai_ACM_CF.pdf},
bdsk-url-2 = {https://doi.org/10.1145/3203217.3205340}
}

• P. Viviani, M. Drocco, and M. Aldinucci, “Pushing the boundaries of parallel deep learning – A practical approach,” Corr, vol. abs/1806.09528, 2018.

This work aims to assess the state of the art of data parallel deep neural network training, trying to identify potential research tracks to be exploited for performance improvement. Beside, it presents a design for a practical C++ library dedicated at implementing and unifying the current state of the art methodologies for parallel training in a performance-conscious framework, allowing the user to explore novel strategies without departing significantly from its usual work-flow.

@article{18:arxiv:deeplearning,
abstract = {This work aims to assess the state of the art of data parallel deep neural network training, trying to identify potential research tracks to be exploited for performance improvement. Beside, it presents a design for a practical C++ library dedicated at implementing and unifying the current state of the art methodologies for parallel training in a performance-conscious framework, allowing the user to explore novel strategies without departing significantly from its usual work-flow.},
author = {Paolo Viviani and Maurizio Drocco and Marco Aldinucci},
journal = {CoRR},
title = {Pushing the boundaries of parallel Deep Learning - {A} practical approach},
url = {https://arxiv.org/pdf/1806.09528},
volume = {abs/1806.09528},
year = {2018},
bdsk-url-1 = {https://arxiv.org/pdf/1806.09528}
}

• C. Misale, M. Drocco, G. Tremblay, A. R. Martinelli, and M. Aldinucci, “Pico: high-performance data analytics pipelines in modern c++,” Future generation computer systems, vol. 87, pp. 392-403, 2018. doi:10.1016/j.future.2018.05.030

In this paper, we present a new C++ API with a fluent interface called PiCo (Pipeline Composition). PiCo’s programming model aims at making easier the programming of data analytics applications while preserving or enhancing their performance. This is attained through three key design choices: (1) unifying batch and stream data access models, (2) decoupling processing from data layout, and (3) exploiting a stream-oriented, scalable, efficient C++11 runtime system. PiCo proposes a programming model based on pipelines and operators that are polymorphic with respect to data types in the sense that it is possible to reuse the same algorithms and pipelines on different data models (e.g., streams, lists, sets, etc.). Preliminary results show that PiCo, when compared to Spark and Flink, can attain better performances in terms of execution times and can hugely improve memory utilization, both for batch and stream processing.

@article{18:fgcs:pico,
abstract = {In this paper, we present a new C++ API with a fluent interface called PiCo (Pipeline Composition). PiCo's programming model aims at making easier the programming of data analytics applications while preserving or enhancing their performance. This is attained through three key design choices: (1) unifying batch and stream data access models, (2) decoupling processing from data layout, and (3) exploiting a stream-oriented, scalable, efficient C++11 runtime system. PiCo proposes a programming model based on pipelines and operators that are polymorphic with respect to data types in the sense that it is possible to reuse the same algorithms and pipelines on different data models (e.g., streams, lists, sets, etc.). Preliminary results show that PiCo, when compared to Spark and Flink, can attain better performances in terms of execution times and can hugely improve memory utilization, both for batch and stream processing.},
author = {Claudia Misale and Maurizio Drocco and Guy Tremblay and Alberto R. Martinelli and Marco Aldinucci},
booktitle = {Future Generation Computer Systems},
date-modified = {2020-11-15 17:22:30 +0100},
doi = {10.1016/j.future.2018.05.030},
journal = {Future Generation Computer Systems},
pages = {392-403},
title = {PiCo: High-performance data analytics pipelines in modern C++},
url = {https://iris.unito.it/retrieve/handle/2318/1668444/414280/fgcs_pico.pdf},
volume = {87},
year = {2018},
bdsk-url-1 = {https://iris.unito.it/retrieve/handle/2318/1668444/414280/fgcs_pico.pdf},
bdsk-url-2 = {https://doi.org/10.1016/j.future.2018.05.030}
}

• P. Viviani, M. Drocco, and M. Aldinucci, “Scaling dense linear algebra on multicore and beyond: a survey,” in Proc. of 26th euromicro intl. conference on parallel distributed and network-based processing (pdp), Cambridge, United Kingdom, 2018. doi:10.1109/PDP2018.2018.00122

The present trend in big-data analytics is to exploit algorithms with (sub-)linear time complexity, in this sense it is usually worth to investigate if the available techniques can be approximated to reach an affordable complexity. However, there are still problems in data science and engineering that involve algorithms with higher time complexity, like matrix inversion or Singular Value Decomposition (SVD). This work presents the results of a survey that reviews a number of tools meant to perform dense linear algebra at “Big Data” scale: namely, the proposed approach aims first to define a feasibility boundary for the problem size of shared-memory matrix factorizations, then to understand whether it is convenient to employ specific tools meant to scale out such dense linear algebra tasks on distributed platforms. The survey will eventually discuss the presented tools from the point of view of domain experts (data scientist, engineers), hence focusing on the trade-off between usability and performance.

@inproceedings{svd:pdp:18,
abstract = {The present trend in big-data analytics is to exploit algorithms with (sub-)linear time complexity, in this sense it is usually worth to investigate if the available techniques can be approximated to reach an affordable complexity. However, there are still problems in data science and engineering that involve algorithms with higher time complexity, like matrix inversion or Singular Value Decomposition (SVD). This work presents the results of a survey that reviews a number of tools meant to perform dense linear algebra at Big Data'' scale: namely, the proposed approach aims first to define a feasibility boundary for the problem size of shared-memory matrix factorizations, then to understand whether it is convenient to employ specific tools meant to scale out such dense linear algebra tasks on distributed platforms. The survey will eventually discuss the presented tools from the point of view of domain experts (data scientist, engineers), hence focusing on the trade-off between usability and performance.},
author = {Paolo Viviani and Maurizio Drocco and Marco Aldinucci},
booktitle = {Proc. of 26th Euromicro Intl. Conference on Parallel Distributed and network-based Processing (PDP)},
date-modified = {2021-04-24 23:23:42 +0200},
doi = {10.1109/PDP2018.2018.00122},
publisher = {IEEE},
title = {Scaling Dense Linear Algebra on Multicore and Beyond: a Survey},
url = {https://iris.unito.it/retrieve/handle/2318/1659340/387685/preprint_aperto.pdf},
year = {2018},
bdsk-url-1 = {https://iris.unito.it/retrieve/handle/2318/1659340/387685/preprint_aperto.pdf},
bdsk-url-2 = {https://doi.org/10.1109/PDP2018.2018.00122}
}

• F. Tordini, M. Aldinucci, P. Viviani, I. Merelli, and P. Liò, “Scientific workflows on clouds with heterogeneous and preemptible instances,” in Proc. of the intl. conference on parallel computing, parco 2017, 12-15 september 2017, bologna, italy, 2018. doi:10.3233/978-1-61499-843-3-605

The cloud environment is increasingly appealing for the HPC community, which has always dealt with scientific applications. However, there is still some skepticism about moving from traditional physical infrastructures to virtual HPC clusters. This mistrusting probably originates from some well known factors, including the effective economy of using cloud services, data and software availability, and the longstanding matter of data stewardship. In this work we discuss the design of a framework (based on Mesos) aimed at achieving a cost-effective and efficient usage of heterogeneous Processing Elements (PEs) for workflow execution, which supports hybrid cloud bursting over preemptible cloud Virtual Machines.

@inproceedings{18:parco:workflow,
abstract = {The cloud environment is increasingly appealing for the HPC community, which has always dealt with scientific applications. However, there is still some skepticism about moving from traditional physical infrastructures to virtual HPC clusters. This mistrusting probably originates from some well known factors, including the effective economy of using cloud services, data and software availability, and the longstanding matter of data stewardship. In this work we discuss the design of a framework (based on Mesos) aimed at achieving a cost-effective and efficient usage of heterogeneous Processing Elements (PEs) for workflow execution, which supports hybrid cloud bursting over preemptible cloud Virtual Machines.},
author = {Fabio Tordini and Marco Aldinucci and Paolo Viviani and Ivan Merelli and Pietro Li{\{o}}},
booktitle = {Proc. of the Intl. Conference on Parallel Computing, ParCo 2017, 12-15 September 2017, Bologna, Italy},
date-modified = {2018-03-13 16:44:11 +0000},
doi = {10.3233/978-1-61499-843-3-605},
keywords = {rephrase},
publisher = {{IOS} Press},
series = {Advances in Parallel Computing},
title = {Scientific Workflows on Clouds with Heterogeneous and Preemptible Instances},
url = {https://iris.unito.it/retrieve/handle/2318/1658510/385411/main.pdf},
year = {2018},
bdsk-url-1 = {https://iris.unito.it/retrieve/handle/2318/1658510/385411/main.pdf},
bdsk-url-2 = {https://doi.org/10.3233/978-1-61499-843-3-605}
}

• P. Viviani, M. Aldinucci, R. d’Ippolito, J. Lemeire, and D. Vucinic, “A flexible numerical framework for engineering–-a response surface modelling application,” in Improved performance of materials: design and experimental approaches, Cham: Springer international publishing, 2018, p. 93–106. doi:10.1007/978-3-319-59590-0_9
[BibTeX] [Abstract]

This work presents an innovative approach adopted for the development of a new numerical software framework for accelerating dense linear algebra calculations and its application within an engineering context. In particular, response surface models (RSM) are a key tool to reduce the computational effort involved in engineering design processes like design optimization. However, RSMs may prove to be too expensive to be computed when the dimensionality of the system and/or the size of the dataset to be synthesized is significantly high or when a large number of different response surfaces has to be calculated in order to improve the overall accuracy (e.g. like when using ensemble modelling techniques). On the other hand, the potential of modern hybrid hardware (e.g. multicore, GPUs) is not exploited by current engineering tools, while they can lead to a significant performance improvement. To fill this gap, a software framework is being developed that enables the hybrid and scalable acceleration of the linear algebra core for engineering applications and especially of RSMs calculations with a user-friendly syntax that allows good portability between different hardware architectures, with no need of specific expertise in parallel programming and accelerator technology. The effectiveness of this framework is shown by comparing an accelerated code to a single-core calculation of a radial basis function RSM on some benchmark datasets. This approach is then validated within a real-life engineering application and the achievements are presented and discussed.

@inbook{17:viviani:advstruct,
abstract = {This work presents an innovative approach adopted for the development of a new numerical software framework for accelerating dense linear algebra calculations and its application within an engineering context. In particular, response surface models (RSM) are a key tool to reduce the computational effort involved in engineering design processes like design optimization. However, RSMs may prove to be too expensive to be computed when the dimensionality of the system and/or the size of the dataset to be synthesized is significantly high or when a large number of different response surfaces has to be calculated in order to improve the overall accuracy (e.g. like when using ensemble modelling techniques). On the other hand, the potential of modern hybrid hardware (e.g. multicore, GPUs) is not exploited by current engineering tools, while they can lead to a significant performance improvement. To fill this gap, a software framework is being developed that enables the hybrid and scalable acceleration of the linear algebra core for engineering applications and especially of RSMs calculations with a user-friendly syntax that allows good portability between different hardware architectures, with no need of specific expertise in parallel programming and accelerator technology. The effectiveness of this framework is shown by comparing an accelerated code to a single-core calculation of a radial basis function RSM on some benchmark datasets. This approach is then validated within a real-life engineering application and the achievements are presented and discussed.},
author = {Viviani, P. and Aldinucci, M. and d'Ippolito, R. and Lemeire, J. and Vucinic, D.},
booktitle = {Improved Performance of Materials: Design and Experimental Approaches},
date-modified = {2018-03-13 16:40:21 +0000},
doi = {10.1007/978-3-319-59590-0_9},
isbn = {978-3-319-59590-0},
keywords = {repara, rephrase},
opteditor = {{\"O}chsner, Andreas and Altenbach, Holm},
pages = {93--106},
publisher = {Springer International Publishing},
title = {A Flexible Numerical Framework for Engineering---A Response Surface Modelling Application},
year = {2018},
bdsk-url-1 = {https://doi.org/10.1007/978-3-319-59590-0_9}
}

• M. Aldinucci, M. Danelutto, M. Drocco, P. Kilpatrick, C. Misale, G. Peretti Pezzi, and M. Torquati, “A parallel pattern for iterative stencil + reduce,” Journal of supercomputing, vol. 74, iss. 11, pp. 5690-5705, 2018. doi:10.1007/s11227-016-1871-z

We advocate the Loop-of-stencil-reduce pattern as a means of simplifying the implementation of data-parallel programs on heterogeneous multi-core platforms. Loop-of-stencil-reduce is general enough to subsume map, reduce, map-reduce, stencil, stencil-reduce, and, crucially, their usage in a loop in both data-parallel and streaming applications, or a combination of both. The pattern makes it possible to deploy a single stencil computation kernel on different GPUs. We discuss the implementation of Loop-of-stencil-reduce in FastFlow, a framework for the implementation of applications based on the parallel patterns. Experiments are presented to illustrate the use of Loop-of-stencil-reduce in developing data-parallel kernels running on heterogeneous systems.

@article{16:stencilreduce:jsupe,
abstract = {We advocate the Loop-of-stencil-reduce pattern as a means of simplifying the implementation of data-parallel programs on heterogeneous multi-core platforms. Loop-of-stencil-reduce is general enough to subsume map, reduce, map-reduce, stencil, stencil-reduce, and, crucially, their usage in a loop in both data-parallel and streaming applications, or a combination of both. The pattern makes it possible to deploy a single stencil computation kernel on different GPUs. We discuss the implementation of Loop-of-stencil-reduce in FastFlow, a framework for the implementation of applications based on the parallel patterns. Experiments are presented to illustrate the use of Loop-of-stencil-reduce in developing data-parallel kernels running on heterogeneous systems.},
author = {Marco Aldinucci and Marco Danelutto and Maurizio Drocco and Peter Kilpatrick and Claudia Misale and Guilherme {Peretti Pezzi} and Massimo Torquati},
date-modified = {2018-12-27 18:19:41 +0100},
doi = {10.1007/s11227-016-1871-z},
journal = {Journal of Supercomputing},
keywords = {nvidia, repara, rephrase},
number = {11},
pages = {5690-5705},
title = {A Parallel Pattern for Iterative Stencil + Reduce},
url = {http://arxiv.org/pdf/1609.04567v1.pdf},
volume = {74},
year = {2018},
bdsk-url-1 = {http://dx.doi.org/10.1007/s11227-016-1871-z},
bdsk-url-2 = {http://arxiv.org/pdf/1609.04567v1.pdf}
}

### 2017

• S. Cuomo, M. Aldinucci, and M. Torquati, “Guest editorial for programming models and algorithms for data analysis in hpc systems,” International journal of parallel programming, p. 1–3, 2017. doi:10.1007/s10766-017-0531-0

Performance is still the hottest keyword in parallel and distributed systems: performance evaluation, design for performance, performance portability and scalability are just a few of the many possible declinations that nowadays are of paramount scientific importance. To tackle these challenges, system architects, applications programmers and data center managers need methodological tools to fit at best the overall workload and the available architecture, maximizing the overall performances and minimizing overheads, energy consumption or idle time while application developers mainly aim at algorithmic and software oriented performances. Proper methodologies for modeling and analysis are the way to turn complexity into opportunities. This Special Issue of the International Journal of Parallel Programming welcomes papers that present practical and methodological approaches to analytical and simulative performance evaluation for architecturally complex systems and high-performance parallel and computing algorithm. Successful contributions have been done on specific technologies, applications and innovative solutions to system specifications and algorithmic schemes both.

@article{17:ijpp:cuomo:editorial,
abstract = {Performance is still the hottest keyword in parallel and distributed systems: performance evaluation, design for performance, performance portability and scalability are just a few of the many possible declinations that nowadays are of paramount scientific importance. To tackle these challenges, system architects, applications programmers and data center managers need methodological tools to fit at best the overall workload and the available architecture, maximizing the overall performances and minimizing overheads, energy consumption or idle time while application developers mainly aim at algorithmic and software oriented performances. Proper methodologies for modeling and analysis are the way to turn complexity into opportunities.
This Special Issue of the International Journal of Parallel Programming welcomes papers that present practical and methodological approaches to analytical and simulative performance evaluation for architecturally complex systems and high-performance parallel and computing algorithm. Successful contributions have been done on specific technologies, applications and innovative solutions to system specifications and algorithmic schemes both.},
author = {Cuomo, Salvatore and Aldinucci, Marco and Torquati, Massimo},
date-modified = {2017-11-12 14:08:30 +0000},
doi = {10.1007/s10766-017-0531-0},
issn = {0885-7458},
journal = {International Journal of Parallel Programming},
keywords = {editorial},
month = {10},
note = {Editorial},
pages = {1--3},
title = {Guest Editorial for Programming Models and Algorithms for Data Analysis in HPC Systems},
url = {https://doi.org/10.1007/s10766-017-0531-0},
year = {2017},
bdsk-url-1 = {http:https://doi.org/10.1007/s10766-017-0531-0},
bdsk-url-2 = {http://dx.doi.org/10.1007/s10766-017-0531-0},
bdsk-url-3 = {https://doi.org/10.1007/s10766-017-0531-0}
}

• M. Aldinucci, M. Danelutto, D. De Sensi, G. Mencagli, and M. Torquati, “Towards power-aware data pipelining on multicores,” in Proceedings of the 10th international symposium on high-level parallel programming and applications, Valladolid, Spain, 2017.

Power consumption management has become a major concern in software development. Continuous streaming computations are usually com- posed by different modules, exchanging data through shared message queues. The selection of the algorithm used to access such queues (i.e., the concurrency control) is a critical aspect for both performance and power consumption. In this paper, we describe the design of an adaptive concurrency control algo- rithm for implementing power-efficient communications on shared memory multicores. The algorithm provides the throughput offered by a nonblocking implementation and the power efficiency of a blocking protocol. We demon- strate that our algorithm reduces the power consumption of data streaming computations without decreasing their throughput.

@inproceedings{17:hlpp:powerstream,
abstract = {Power consumption management has become a major concern in software development. Continuous streaming computations are usually com- posed by different modules, exchanging data through shared message queues. The selection of the algorithm used to access such queues (i.e., the concurrency control) is a critical aspect for both performance and power consumption. In this paper, we describe the design of an adaptive concurrency control algo- rithm for implementing power-efficient communications on shared memory multicores. The algorithm provides the throughput offered by a nonblocking implementation and the power efficiency of a blocking protocol. We demon- strate that our algorithm reduces the power consumption of data streaming computations without decreasing their throughput.},
author = {Marco Aldinucci and Marco Danelutto and De Sensi, Daniele and Gabriele Mencagli and Massimo Torquati},
booktitle = {Proceedings of the 10th International Symposium on High-Level Parallel Programming and Applications},
date-modified = {2018-12-27 18:53:27 +0100},
keywords = {rephrase, fastflow},
title = {Towards Power-Aware Data Pipelining on Multicores},
url = {https://iris.unito.it/retrieve/handle/2318/1644982/351415/17_HLPP_powerstream.pdf},
year = {2017},
bdsk-url-1 = {https://iris.unito.it/retrieve/handle/2318/1644982/351415/17_HLPP_powerstream.pdf}
}

• C. Misale, M. Drocco, M. Aldinucci, and G. Tremblay, “A comparison of big data frameworks on a layered dataflow model,” Parallel processing letters, vol. 27, iss. 01, p. 1–20, 2017. doi:10.1142/S0129626417400035

In the world of Big Data analytics, there is a series of tools aiming at simplifying programming applications to be executed on clusters. Although each tool claims to provide better programming, data and execution models, for which only informal (and often confusing) semantics is generally provided, all share a common underlying model, namely, the Dataflow model. The Dataflow model we propose shows how various tools share the same expressiveness at different levels of abstraction. The contribution of this work is twofold: first, we show that the proposed model is (at least) as general as existing batch and streaming frameworks (e.g., Spark, Flink, Storm), thus making it easier to understand high-level data-processing applications written in such frameworks. Second, we provide a layered model that can represent tools and applications following the Dataflow paradigm and we show how the analyzed tools fit in each level.

@article{17:bigdatasurvey:PPL,
abstract = {In the world of Big Data analytics, there is a series of tools aiming at simplifying programming applications to be executed on clusters. Although each tool claims to provide better programming, data and execution models, for which only informal (and often confusing) semantics is generally provided, all share a common underlying model, namely, the Dataflow model. The Dataflow model we propose shows how various tools share the same expressiveness at different levels of abstraction. The contribution of this work is twofold: first, we show that the proposed model is (at least) as general as existing batch and streaming frameworks (e.g., Spark, Flink, Storm), thus making it easier to understand high-level data-processing applications written in such frameworks. Second, we provide a layered model that can represent tools and applications following the Dataflow paradigm and we show how the analyzed tools fit in each level.},
author = {Misale, Claudia and Drocco, Maurizio and Aldinucci, Marco and Tremblay, Guy},
date-modified = {2017-12-12 12:16:32 +0000},
date-published = {March 2017},
doi = {10.1142/S0129626417400035},
eprint = {http://www.worldscientific.com/doi/pdf/10.1142/S0129626417400035},
journal = {Parallel Processing Letters},
number = {01},
pages = {1--20},
title = {A Comparison of Big Data Frameworks on a Layered Dataflow Model},
url = {https://iris.unito.it/retrieve/handle/2318/1626287/303421/preprintPPL_4aperto.pdf},
volume = {27},
year = {2017},
bdsk-url-1 = {https://iris.unito.it/retrieve/handle/2318/1626287/303421/preprintPPL_4aperto.pdf},
bdsk-url-2 = {http://dx.doi.org/10.1142/S0129626417400035}
}

• P. Viviani, M. Torquati, M. Aldinucci, and R. d’Ippolito, “Multiple back-end support for the armadillo linear algebra interface,” in In proc. of the 32nd acm symposium on applied computing (sac), Marrakesh, Morocco, 2017, p. 1566–1573.

The Armadillo C++ library provides programmers with a high-level Matlab-like syntax for linear algebra. Its design aims at providing a good balance between speed and ease of use. It can be linked with different back-ends, i.e. different LAPACK-compliant libraries. In this work we present a novel run-time support of Armadillo, which gracefully extends mainstream implementation to enable back-end switching without recompilation and multiple back-end support. The extension is specifically designed to not affect Armadillo class template prototypes, thus to be easily interoperable with future evolutions of the Armadillo library itself. The proposed software stack is then tested for functionality and performance against a kernel code extracted from an industrial application.

@inproceedings{17:sac:armadillo,
abstract = {The Armadillo C++ library provides programmers with a high-level Matlab-like syntax for linear algebra. Its design aims at providing a good balance between speed and ease of use. It can be linked with different back-ends, i.e. different LAPACK-compliant libraries. In this work we present a novel run-time support of Armadillo, which gracefully extends mainstream implementation to enable back-end switching without recompilation and multiple back-end support. The extension is specifically designed to not affect Armadillo class template prototypes, thus to be easily interoperable with future evolutions of the Armadillo library itself. The proposed software stack is then tested for functionality and performance against a kernel code extracted from an industrial application.},
author = {Paolo Viviani and Massimo Torquati and Marco Aldinucci and Roberto d'Ippolito},
booktitle = {In proc. of the 32nd ACM Symposium on Applied Computing (SAC)},
date-modified = {2017-06-13 15:54:43 +0000},
keywords = {nvidia, repara, rephrase, itea2},
month = apr,
pages = {1566--1573},
title = {Multiple back-end support for the Armadillo linear algebra interface},
year = {2017},
}

• M. Aldinucci, M. Danelutto, P. Kilpatrick, and M. Torquati, “Fastflow: high-level and efficient streaming on multi-core,” in Programming multi-core and many-core computing systems, S. Pllana and F. Xhafa, Eds., John wiley & sons, ltd, 2017, pp. 261-280. doi:10.1002/9781119332015.ch13

This chapter first outlines FastFlow design and then shows sample use of the FastFlow programming environment together with performance results achieved on various state-of-the-art multicore architectures. The FastFlow framework has been designed according to four foundational principles: layered design; efficiency in base mechanisms; support for stream parallelism; and a programming model based on design pattern/algorithmic skeleton concepts. The core of the FastFlow framework provides an efficient implementation of single-producer-single-consumer (SPSC) first in-first out (FIFO) queues. The next tier up extends from one-to-one queues to one-to-many, many-to-one, and many-to-many synchronizations and data flows, which are implemented using only SPSC queues and arbiter threads, thus providing lock-free and wait-free arbitrary dataflow graphs. When designing and implementing new parallel applications using FastFlow, programmers instantiate patterns provided by FastFlow to adapt them to the specific needs of the application at hand. The chapter demonstrates how the principal FastFlow patterns may be used in a parallel application.

@inbook{ff:wileybook:17,
abstract = {This chapter first outlines FastFlow design and then shows sample use of the FastFlow programming environment together with performance results achieved on various state-of-the-art multicore architectures. The FastFlow framework has been designed according to four foundational principles: layered design; efficiency in base mechanisms; support for stream parallelism; and a programming model based on design pattern/algorithmic skeleton concepts. The core of the FastFlow framework provides an efficient implementation of single-producer-single-consumer (SPSC) first in-first out (FIFO) queues. The next tier up extends from one-to-one queues to one-to-many, many-to-one, and many-to-many synchronizations and data flows, which are implemented using only SPSC queues and arbiter threads, thus providing lock-free and wait-free arbitrary dataflow graphs. When designing and implementing new parallel applications using FastFlow, programmers instantiate patterns provided by FastFlow to adapt them to the specific needs of the application at hand. The chapter demonstrates how the principal FastFlow patterns may be used in a parallel application.},
author = {Marco Aldinucci and Marco Danelutto and Peter Kilpatrick and Massimo Torquati},
booktitle = {Programming Multi-core and Many-core Computing Systems},
chapter = {13},
date-modified = {2014-12-31 14:14:28 +0000},
doi = {10.1002/9781119332015.ch13},
editor = {Sabri Pllana and Fatos Xhafa},
isbn = {9781119332015},
keywords = {fastflow},
optannote = {ISBN: 0470936908},
pages = {261-280},
publisher = {John Wiley \& Sons, Ltd},
series = {Parallel and Distributed Computing},
title = {FastFlow: high-level and efficient streaming on multi-core},
year = {2017},
bdsk-url-2 = {https://dx.doi.org/10.1002/9781119332015.ch13}
}

• F. Tordini, M. Drocco, C. Misale, L. Milanesi, P. Liò, I. Merelli, M. Torquati, and M. Aldinucci, “NuChart-II: the road to a fast and scalable tool for Hi-C data analysis,” International journal of high performance computing applications, vol. 31, iss. 3, pp. 196-211, 2017. doi:10.1177/1094342016668567

Recent advances in molecular biology and bioinformatics techniques brought to an explosion of the information about the spatial organisation of the DNA in the nucleus of a cell. High-throughput molecular biology techniques provide a genome-wide capture of the spatial organization of chromosomes at unprecedented scales, which permit to identify physical interactions between genetic elements located throughout a genome. Recent results have shown that there is a large correlation between co-localization and co-regulation of genes, but these important information are hampered by the lack of biologists-friendly analysis and visualisation software. In this work we present NuChart-II, an efficient and highly optimized tool for genomic data analysis that provides a gene-centric, graph-based representation of genomic information. While designing NuChart-II we addressed several common issues in the parallelisation of memory bound algorithms for shared-memory systems. With performance and usability in mind, NuChart-II is a R package that embeds a C++ engine: computing capabilities and memory hierarchy of multi-core architectures are fully exploited, while the versatile R environment for statistical analysis and data visualisation rises the level of abstraction and permits to orchestrate analysis and visualisation of genomic data.

@article{16:ijhpca:nuchart,
abstract = {Recent advances in molecular biology and bioinformatics techniques brought to an explosion of the information about the spatial organisation of the DNA in the nucleus of a cell. High-throughput molecular biology techniques provide a genome-wide capture of the spatial organization of chromosomes at unprecedented scales, which permit to identify physical interactions between genetic elements located throughout a genome. Recent results have shown that there is a large correlation between co-localization and co-regulation of genes, but these important information are hampered by the lack of biologists-friendly analysis and visualisation software. In this work we present NuChart-II, an efficient and highly optimized tool for genomic data analysis that provides a gene-centric, graph-based representation of genomic information. While designing NuChart-II we addressed several common issues in the parallelisation of memory bound algorithms for shared-memory systems. With performance and usability in mind, NuChart-II is a R package that embeds a C++ engine: computing capabilities and memory hierarchy of multi-core architectures are fully exploited, while the versatile R environment for statistical analysis and data visualisation rises the level of abstraction and permits to orchestrate analysis and visualisation of genomic data.},
author = {Fabio Tordini and Maurizio Drocco and Claudia Misale and Luciano Milanesi and Pietro Li{\o} and Ivan Merelli and Massimo Torquati and Marco Aldinucci},
date-modified = {2018-12-27 19:06:22 +0100},
doi = {10.1177/1094342016668567},
journal = {International Journal of High Performance Computing Applications},
keywords = {fastflow, bioinformatics, repara, rephrase, interomics, mimomics},
number = {3},
pages = {196-211},
title = {{NuChart-II}: the road to a fast and scalable tool for {Hi-C} data analysis},
url = {https://iris.unito.it/retrieve/handle/2318/1607126/238747/main.pdf},
volume = {31},
year = {2017},
bdsk-url-1 = {http://hdl.handle.net/2318/1607126},
bdsk-url-2 = {http://dx.doi.org/10.1177/1094342016668567},
bdsk-url-3 = {https://iris.unito.it/retrieve/handle/2318/1607126/238747/main.pdf}
}

• M. Aldinucci, S. Bagnasco, S. Lusso, P. Pasteris, and S. Rabellino, “Occam: a flexible, multi-purpose and extendable hpc cluster,” in Journal of physics: conf. series (chep 2016), San Francisco, USA, 2017, p. 82039. doi:10.1088/1742-6596/898/8/082039

Obtaining CPU cycles on an HPC cluster is nowadays relatively simple and sometimes even cheap for academic institutions. However, in most of the cases providers of HPC services would not allow changes on the configuration, implementation of special features or a lower-level control on the computing infrastructure and networks, for example for testing new computing patterns or conducting research on HPC itself. The variety of use cases proposed by several departments of the University of Torino, including ones from solid-state chemistry, high-energy physics, computer science, big data analytics, computational biology, genomics and many others, called for different and sometimes conflicting configurations; furthermore, several R&D activities in the field of scientific computing, with topics ranging from GPU acceleration to Cloud Computing technologies, needed a platform to be carried out on. The Open Computing Cluster for Advanced data Manipulation (OCCAM) is a multi-purpose flexible HPC cluster designed and operated by a collaboration between the University of Torino and the Torino branch of the Istituto Nazionale di Fisica Nucleare. It is aimed at providing a flexible, reconfigurable and extendable infrastructure to cater to a wide range of different scientific computing needs, as well as a platform for R&D activities on computational technologies themselves. Extending it with novel architecture CPU, accelerator or hybrid microarchitecture (such as forthcoming Intel Xeon Phi Knights Landing) should be as a simple as plugging a node in a rack. The initial system counts slightly more than 1100 cpu cores and includes different types of computing nodes (standard dual-socket nodes, large quad-sockets nodes with 768 GB RAM, and multi-GPU nodes) and two separate disk storage subsystems: a smaller high-performance scratch area, based on the Lustre file system, intended for direct computational I/O and a larger one, of the order of 1PB, to archive near-line data for archival purposes. All the components of the system are interconnected through a 10Gb/s Ethernet layer with one-level topology and an InfiniBand FDR 56Gbps layer in fat-tree topology. A system of this kind, heterogeneous and reconfigurable by design, poses a number of challenges related to the frequency at which heterogeneous hardware resources might change their availability and shareability status, which in turn affect methods and means to allocate, manage, optimize, bill, monitor VMs, virtual farms, jobs, interactive bare-metal sessions, etc. This poster describes some of the use cases that prompted the design ad construction of the HPC cluster, its architecture and a first characterization of its performance by some synthetic benchmark tools and a few realistic use-case tests.

@inproceedings{16:occam:chep,
abstract = {Obtaining CPU cycles on an HPC cluster is nowadays relatively simple and sometimes even cheap for academic institutions. However, in most of the cases providers of HPC services would not allow changes on the configuration, implementation of special features or a lower-level control on the computing infrastructure and networks, for example for testing new computing patterns or conducting research on HPC itself. The variety of use cases proposed by several departments of the University of Torino, including ones from solid-state chemistry, high-energy physics, computer science, big data analytics, computational biology, genomics and many others, called for different and sometimes conflicting configurations; furthermore, several R&D activities in the field of scientific computing, with topics ranging from GPU acceleration to Cloud Computing technologies, needed a platform to be carried out on.
The Open Computing Cluster for Advanced data Manipulation (OCCAM) is a multi-purpose flexible HPC cluster designed and operated by a collaboration between the University of Torino and the Torino branch of the Istituto Nazionale di Fisica Nucleare. It is aimed at providing a flexible, reconfigurable and extendable infrastructure to cater to a wide range of different scientific computing needs, as well as a platform for R&D activities on computational technologies themselves. Extending it with novel architecture CPU, accelerator or hybrid microarchitecture (such as forthcoming Intel Xeon Phi Knights Landing) should be as a simple as plugging a node in a rack.
The initial system counts slightly more than 1100 cpu cores and includes different types of computing nodes (standard dual-socket nodes, large quad-sockets nodes with 768 GB RAM, and multi-GPU nodes) and two separate disk storage subsystems: a smaller high-performance scratch area, based on the Lustre file system, intended for direct computational I/O and a larger one, of the order of 1PB, to archive near-line data for archival purposes. All the components of the system are interconnected through a 10Gb/s Ethernet layer with one-level topology and an InfiniBand FDR 56Gbps layer in fat-tree topology.
A system of this kind, heterogeneous and reconfigurable by design, poses a number of challenges related to the frequency at which heterogeneous hardware resources might change their availability and shareability status, which in turn affect methods and means to allocate, manage, optimize, bill, monitor VMs, virtual farms, jobs, interactive bare-metal sessions, etc.
This poster describes some of the use cases that prompted the design ad construction of the HPC cluster, its architecture and a first characterization of its performance by some synthetic benchmark tools and a few realistic use-case tests.
},
author = {Marco Aldinucci and Stefano Bagnasco and Stefano Lusso and Paolo Pasteris and Sergio Rabellino},
booktitle = {Journal of Physics: Conf. Series (CHEP 2016)},
date-modified = {2018-12-27 18:44:37 +0100},
doi = {10.1088/1742-6596/898/8/082039},
keywords = {nvidia, c3s},
number = {8},
optmonth = oct,
pages = {082039},
title = {OCCAM: a flexible, multi-purpose and extendable HPC cluster},
url = {http://iopscience.iop.org/article/10.1088/1742-6596/898/8/082039/meta},
volume = {898},
year = {2017},
bdsk-url-1 = {http://iopscience.iop.org/article/10.1088/1742-6596/898/8/082039/meta},
bdsk-url-2 = {http://dx.doi.org/10.1088/1742-6596/898/8/082039}
}

• C. Spampinato, S. Palazzo, D. Giordano, M. Aldinucci, and R. Leonardi, “Deep learning for automated skeletal bone age assessment in x-ray images,” Medical image analysis, vol. 36, pp. 41-51, 2017. doi:10.1016/j.media.2016.10.010

Skeletal bone age assessment is a common clinical practice to investigate endocrinology, genetic and growth disorders in children. It is generally performed by radiological examination of the left hand by using either the Greulich and Pyle (G&P) method or the Tanner–Whitehouse (TW) one. However, both clinical procedures show several limitations, from the examination effort of radiologists to (most importantly) significant intra- and inter-operator variability. To address these problems, several automated approaches (especially relying on the TW method) have been proposed; nevertheless, none of them has been proved able to generalize to different races, age ranges and genders. In this paper, we propose and test several deep learning approaches to assess skeletal bone age automatically; the results showed an average discrepancy between manual and automatic evaluation of about 0.8 years, which is state-of-the-art performance. Furthermore, this is the first automated skeletal bone age assessment work tested on a public dataset and for all age ranges, races and genders, for which the source code is available, thus representing an exhaustive baseline for future research in the field. Beside the specific application scenario, this paper aims at providing answers to more general questions about deep learning on medical images: from the comparison between deep-learned features and manually-crafted ones, to the usage of deep-learning methods trained on general imagery for medical problems, to how to train a CNN with few images.

@article{17:deepx:conce,
abstract = {Skeletal bone age assessment is a common clinical practice to investigate endocrinology, genetic and growth disorders in children. It is generally performed by radiological examination of the left hand by using either the Greulich and Pyle (G&P) method or the Tanner--Whitehouse (TW) one. However, both clinical procedures show several limitations, from the examination effort of radiologists to (most importantly) significant intra- and inter-operator variability. To address these problems, several automated approaches (especially relying on the TW method) have been proposed; nevertheless, none of them has been proved able to generalize to different races, age ranges and genders. In this paper, we propose and test several deep learning approaches to assess skeletal bone age automatically; the results showed an average discrepancy between manual and automatic evaluation of about 0.8 years, which is state-of-the-art performance. Furthermore, this is the first automated skeletal bone age assessment work tested on a public dataset and for all age ranges, races and genders, for which the source code is available, thus representing an exhaustive baseline for future research in the field. Beside the specific application scenario, this paper aims at providing answers to more general questions about deep learning on medical images: from the comparison between deep-learned features and manually-crafted ones, to the usage of deep-learning methods trained on general imagery for medical problems, to how to train a CNN with few images.},
author = {Concetto Spampinato and Simone Palazzo and Daniela Giordano and Marco Aldinucci and Rosalia Leonardi},
doi = {10.1016/j.media.2016.10.010},
journal = {Medical Image Analysis},
keywords = {nvidia},
pages = {41-51},
title = {Deep learning for automated skeletal bone age assessment in X-ray images},
url = {https://iris.unito.it/retrieve/handle/2318/1607122/341353/main.pdf},
volume = {36},
year = {2017},
bdsk-url-1 = {http://dx.doi.org/10.1016/j.media.2016.10.010},
bdsk-url-2 = {https://iris.unito.it/retrieve/handle/2318/1607122/341353/main.pdf}
}

### 2016

• P. Viviani, M. Aldinucci, and R. d’Ippolito, “An hybrid linear algebra framework for engineering,” in Advanced computer architecture and compilation for high-performance and embedded systems (acaces) – poster abstracts, Fiuggi, Italy, 2016.

The aim of this work is to provide developers and domain experts with simple (Matlab-like) inter- face for performing linear algebra tasks while retaining state-of-the-art computational speed. To achieve this goal we extend Armadillo C++ library is extended in order to support with multiple LAPACK-compliant back-ends targeting different architectures including CUDA GPUs; moreover our approach involves the possibility of dynamically switching between such back-ends in order to select the one which is most convenient based on the specific problem and hardware configura- tion. This approach is eventually validated within an industrial environment.

@inproceedings{16:acaces:armadillo,
abstract = {The aim of this work is to provide developers and domain experts with simple (Matlab-like) inter- face for performing linear algebra tasks while retaining state-of-the-art computational speed. To achieve this goal we extend Armadillo C++ library is extended in order to support with multiple LAPACK-compliant back-ends targeting different architectures including CUDA GPUs; moreover our approach involves the possibility of dynamically switching between such back-ends in order to select the one which is most convenient based on the specific problem and hardware configura- tion. This approach is eventually validated within an industrial environment.},
author = {Paolo Viviani and Marco Aldinucci and Roberto d'Ippolito},
booktitle = {Advanced Computer Architecture and Compilation for High-Performance and Embedded Systems (ACACES) -- Poster Abstracts},
date-modified = {2020-11-15 15:01:16 +0100},
keywords = {nvidia, gpu, itea2, repara},
month = {July},
title = {An hybrid linear algebra framework for engineering},
year = {2016},
}

• P. Viviani, M. Aldinucci, R. d’Ippolito, J. Lemeire, and D. Vucinic, A flexible numerical framework for engineering – a response surface modelling application, 2016.
[BibTeX] [Abstract]

This work presents the innovative approach adopted for the development of a new numerical software framework for accelerating Dense Linear Algebra calculations and its application within an engineering context. In particular, Response Surface Models (RSM) are a key tool to reduce the computational effort involved in engineering design processes like design optimization. However, RSMs may prove to be too expensive to be computed when the dimensionality of the system and/or the size of the dataset to be synthesized is significantly high or when a large number of different Response Surfaces has to be calculated in order to improve the overall accuracy (e.g. like when using Ensemble Modelling techniques). On the other hand, it is a known challenge that the potential of modern hybrid hardware (e.g. multicore, GPUs) is not exploited by current engineering tools, while they can lead to a significant performance improvement. To fill this gap, a software framework is being developed that enables the hybrid and scalable acceleration of the linear algebra core for engineering applications and especially of RSMs calculations with a user-friendly syntax that allows good portability between different hardware architectures, with no need of specific expertise in parallel programming and accelerator technology. The effectiveness of this framework is shown by comparing an accelerated code to a single-core calculation of a Radial Basis Function RSM on some benchmark datasets. This approach is then validated within a real-life engineering application and the achievements are presented and discussed.

@unpublished{16:acex:armadillo,
abstract = {This work presents the innovative approach adopted for the development of a new numerical software framework for accelerating Dense Linear Algebra calculations and its application within an engineering context.
In particular, Response Surface Models (RSM) are a key tool to reduce the computational effort involved in engineering design processes like design optimization. However, RSMs may prove to be too expensive to be computed when the dimensionality of the system and/or the size of the dataset to be synthesized is significantly high or when a large number of different Response Surfaces has to be calculated in order to improve the overall accuracy (e.g. like when using Ensemble Modelling techniques).
On the other hand, it is a known challenge that the potential of modern hybrid hardware (e.g. multicore, GPUs) is not exploited by current engineering tools, while they can lead to a significant performance improvement. To fill this gap, a software framework is being developed that enables the hybrid and scalable acceleration of the linear algebra core for engineering applications and especially of RSMs calculations with a user-friendly syntax that allows good portability between different hardware architectures, with no need of specific expertise in parallel programming and accelerator technology.
The effectiveness of this framework is shown by comparing an accelerated code to a single-core calculation of a Radial Basis Function RSM on some benchmark datasets. This approach is then validated within a real-life engineering application and the achievements are presented and discussed.
},
author = {Paolo Viviani and Marco Aldinucci and Roberto d'Ippolito and Jean Lemeire and Dean Vucinic},
booktitle = {10th Intl. Conference on Advanced Computational Engineering and Experimenting (ACE-X)},
date-modified = {2019-08-08 11:27:47 +0200},
keywords = {repara, rephrase, nvidia, gpu},
title = {A flexible numerical framework for engineering - a Response Surface Modelling application},
year = {2016}
}

• C. Misale, M. Drocco, M. Aldinucci, and G. Tremblay, “A comparison of big data frameworks on a layered dataflow model,” in Proc. of intl. workshop on high-level parallel programming (hlpp), Muenster, Germany, 2016, pp. 1-19. doi:10.5281/zenodo.321866

In the world of Big Data analytics, there is a series of tools aiming at simplifying programming applications to be executed on clusters. Although each tool claims to provide better programming, data and execution models, for which only informal (and often confusing) semantics is generally provided, all share a common underlying model, namely, the Dataflow model. The Dataflow model we propose shows how various tools share the same expressiveness at different levels of abstraction. The contribution of this work is twofold: first, we show that the proposed model is (at least) as general as existing batch and streaming frameworks (e.g., Spark, Flink, Storm), thus making it easier to understand high-level data-processing applications written in such frameworks. Second, we provide a layered model that can represent tools and applications following the Dataflow paradigm and we show how the analyzed tools fit in each level.

@inproceedings{16:bigdatasurvey:hlpp,
abstract = {In the world of Big Data analytics, there is a series of tools aiming at simplifying programming applications to be executed on clusters. Although each tool claims to provide better programming, data and execution models, for which only informal (and often confusing) semantics is generally provided, all share a common underlying model, namely, the Dataflow model. The Dataflow model we propose shows how various tools share the same expressiveness at different levels of abstraction. The contribution of this work is twofold: first, we show that the proposed model is (at least) as general as existing batch and streaming frameworks (e.g., Spark, Flink, Storm), thus making it easier to understand high-level data-processing applications written in such frameworks. Second, we provide a layered model that can represent tools and applications following the Dataflow paradigm and we show how the analyzed tools fit in each level.},
author = {Claudia Misale and Maurizio Drocco and Marco Aldinucci and Guy Tremblay},
booktitle = {Proc. of Intl. Workshop on High-Level Parallel Programming (HLPP)},
date-modified = {2017-12-12 14:49:47 +0000},
doi = {10.5281/zenodo.321866},
month = jul,
pages = {1-19},
publisher = {arXiv.org},
title = {A Comparison of Big Data Frameworks on a Layered Dataflow Model},
url = {http://arxiv.org/pdf/1606.05293v1.pdf},
year = {2016},
bdsk-url-1 = {http://arxiv.org/pdf/1606.05293v1.pdf},
bdsk-url-2 = {http://dx.doi.org/10.5281/zenodo.321866}
}

• M. Drocco, C. Misale, and M. Aldinucci, “A cluster-as-accelerator approach for SPMD-free data parallelism,” in Proc. of 24th euromicro intl. conference on parallel distributed and network-based processing (pdp), Crete, Greece, 2016, p. 350–353. doi:10.1109/PDP.2016.97

In this paper we present a novel approach for functional-style programming of distributed-memory clusters, targeting data-centric applications. The programming model proposed is purely sequential, SPMD-free and based on high- level functional features introduced since C++11 specification. Additionally, we propose a novel cluster-as-accelerator design principle. In this scheme, cluster nodes act as general inter- preters of user-defined functional tasks over node-local portions of distributed data structures. We envision coupling a simple yet powerful programming model with a lightweight, locality- aware distributed runtime as a promising step along the road towards high-performance data analytics, in particular under the perspective of the upcoming exascale era. We implemented the proposed approach in SkeDaTo, a prototyping C++ library of data-parallel skeletons exploiting cluster-as-accelerator at the bottom layer of the runtime software stack.

@inproceedings{skedato:pdp:16,
abstract = {In this paper we present a novel approach for functional-style programming of distributed-memory clusters, targeting data-centric applications. The programming model proposed is purely sequential, SPMD-free and based on high- level functional features introduced since C++11 specification. Additionally, we propose a novel cluster-as-accelerator design principle. In this scheme, cluster nodes act as general inter- preters of user-defined functional tasks over node-local portions of distributed data structures. We envision coupling a simple yet powerful programming model with a lightweight, locality- aware distributed runtime as a promising step along the road towards high-performance data analytics, in particular under the perspective of the upcoming exascale era. We implemented the proposed approach in SkeDaTo, a prototyping C++ library of data-parallel skeletons exploiting cluster-as-accelerator at the bottom layer of the runtime software stack.},
author = {Maurizio Drocco and Claudia Misale and Marco Aldinucci},
booktitle = {Proc. of 24th Euromicro Intl. Conference on Parallel Distributed and network-based Processing (PDP)},
date-modified = {2017-12-12 14:49:31 +0000},
doi = {10.1109/PDP.2016.97},
keywords = {rephrase, fastflow},
pages = {350--353},
publisher = {IEEE},
title = {A Cluster-As-Accelerator approach for {SPMD}-free Data Parallelism},
url = {https://iris.unito.it/retrieve/handle/2318/1611858/262689/2016_pdp_skedato.pdf},
year = {2016},
bdsk-url-1 = {https://iris.unito.it/retrieve/handle/2318/1611858/262689/2016_pdp_skedato.pdf},
bdsk-url-2 = {https://doi.org/10.1109/PDP.2016.97}
}

• V. Janjic, C. Brown, K. MacKenzie, K. and Hammond, M. Danelutto, M. Aldinucci, and J. D. Garcia, “RPL: a domain-specific language for designing and implementing parallel c++ applications,” in Proc. of intl. euromicro pdp 2016: parallel distributed and network-based processing, Crete, Greece, 2016. doi:10.1109/PDP.2016.122

Parallelising sequential applications is usually a very hard job, due to many different ways in which an application can be parallelised and a large number of programming models (each with its own advantages and disadvantages) that can be used. In this paper, we describe a method to semi- automatically generate and evaluate different parallelisations of the same application, allowing programmers to find the best parallelisation without significant manual reengineering of the code. We describe a novel, high-level domain-specific language, Refactoring Pattern Language (RPL), that is used to represent the parallel structure of an application and to capture its extra-functional properties (such as service time). We then describe a set of RPL rewrite rules that can be used to generate alternative, but semantically equivalent, parallel structures (parallelisations) of the same application. We also describe the RPL Shell that can be used to evaluate these parallelisations, in terms of the desired extra-functional properties. Finally, we describe a set of C++ refactorings, targeting OpenMP, Intel TBB and FastFlow parallel programming models, that semi-automatically apply the desired parallelisation to the application’s source code, therefore giving a parallel version of the code. We demonstrate how the RPL and the refactoring rules can be used to derive efficient parallelisations of two realistic C++ use cases (Image Convolution and Ant Colony Optimisation).

@inproceedings{rpl:pdp:16,
abstract = {Parallelising sequential applications is usually a very hard job, due to many different ways in which an application can be parallelised and a large number of programming models (each with its own advantages and disadvantages) that can be used. In this paper, we describe a method to semi- automatically generate and evaluate different parallelisations of the same application, allowing programmers to find the best parallelisation without significant manual reengineering of the code. We describe a novel, high-level domain-specific language, Refactoring Pattern Language (RPL), that is used to represent the parallel structure of an application and to capture its extra-functional properties (such as service time). We then describe a set of RPL rewrite rules that can be used to generate alternative, but semantically equivalent, parallel structures (parallelisations) of the same application. We also describe the RPL Shell that can be used to evaluate these parallelisations, in terms of the desired extra-functional properties. Finally, we describe a set of C++ refactorings, targeting OpenMP, Intel TBB and FastFlow parallel programming models, that semi-automatically apply the desired parallelisation to the application's source code, therefore giving a parallel version of the code. We demonstrate how the RPL and the refactoring rules can be used to derive efficient parallelisations of two realistic C++ use cases (Image Convolution and Ant Colony Optimisation).},
author = {Vladimir Janjic and Christopher Brown and Kenneth MacKenzie and and Kevin Hammond and Marco Danelutto and Marco Aldinucci and Jose Daniel Garcia},
booktitle = {Proc. of Intl. Euromicro PDP 2016: Parallel Distributed and network-based Processing},
date-modified = {2017-06-20 08:19:39 +0000},
doi = {10.1109/PDP.2016.122},
keywords = {rephrase, fastflow},
publisher = {IEEE},
title = {{RPL}: A Domain-Specific Language for Designing and Implementing Parallel C++ Applications},
url = {https://iris.unito.it/retrieve/handle/2318/1597172/299237/2016_jsupe_stencil_pp_4aperto.pdf},
year = {2016},
bdsk-url-1 = {http://hdl.handle.net/2318/1597172},
bdsk-url-2 = {https://iris.unito.it/retrieve/handle/2318/1597172/299237/2016_jsupe_stencil_pp_4aperto.pdf},
bdsk-url-3 = {http://dx.doi.org/10.1109/PDP.2016.122}
}

• M. Aldinucci, S. Campa, M. Danelutto, P. Kilpatrick, and M. Torquati, “Pool evolution: a parallel pattern for evolutionary and symbolic computing,” International journal of parallel programming, vol. 44, iss. 3, p. 531–551, 2016. doi:10.1007/s10766-015-0358-5

We introduce a new parallel pattern derived from a specific application domain and show how it turns out to have application beyond its domain of origin. The pool evolution pattern models the parallel evolution of a population subject to mutations and evolving in such a way that a given fitness function is optimized. The pattern has been demonstrated to be suitable for capturing and modeling the parallel patterns underpinning various evolutionary algorithms, as well as other parallel patterns typical of symbolic computation. In this paper we introduce the pattern, we discuss its implementation on modern multi/many core architectures and finally present experimental results obtained with FastFlow and Erlang implementations to assess its feasibility and scalability.

@article{pool:ijpp:15,
abstract = {We introduce a new parallel pattern derived from a specific application domain and show how it turns out to have application beyond its domain of origin. The pool evolution pattern models the parallel evolution of a population subject to mutations and evolving in such a way that a given fitness function is optimized. The pattern has been demonstrated to be suitable for capturing and modeling the parallel patterns underpinning various evolutionary algorithms, as well as other parallel patterns typical of symbolic computation. In this paper we introduce the pattern, we discuss its implementation on modern multi/many core architectures and finally present experimental results obtained with FastFlow and Erlang implementations to assess its feasibility and scalability.},
author = {Marco Aldinucci and Sonia Campa and Marco Danelutto and Peter Kilpatrick and Massimo Torquati},
date-modified = {2015-09-24 11:15:53 +0000},
doi = {10.1007/s10766-015-0358-5},
issn = {0885-7458},
journal = {International Journal of Parallel Programming},
keywords = {fastflow, paraphrase, repara},
number = {3},
pages = {531--551},
publisher = {Springer US},
title = {Pool Evolution: A Parallel Pattern for Evolutionary and Symbolic Computing},
url = {https://iris.unito.it/retrieve/handle/2318/1522392/42139/2015_ff_pool_ijpp.pdf},
volume = {44},
year = {2016},
bdsk-url-1 = {https://iris.unito.it/retrieve/handle/2318/1522392/42139/2015_ff_pool_ijpp.pdf},
bdsk-url-2 = {https://doi.org/10.1007/s10766-015-0358-5}
}

• F. Tordini, I. Merelli, P. Liò, L. Milanesi, and M. Aldinucci, “NuchaRt: embedding high-level parallel computing in R for augmented Hi-C data analysis,” in Computational intelligence methods for bioinformatics and biostatistics, S. I. Publishing, Ed., Cham (ZG): Springer international publishing, 2016, vol. 9874, p. 259–272. doi:10.1007/978-3-319-44332-4

Recent advances in molecular biology and Bioinformatics techniques brought to an explosion of the information about the spatial organisation of the DNA in the nucleus. High-throughput chromosome conformation capture techniques provide a genome-wide capture of chromatin contacts at unprecedented scales, which permit to identify physical interactions between genetic elements located throughout the human genome. These important studies are hampered by the lack of biologists-friendly software. In this work we present NuchaRt, an R package that wraps NuChart-II, an efficient and highly optimized C++ tool for the exploration of Hi-C data. By rising the level of abstraction, NuchaRt proposes a high-performance pipeline that allows users to orchestrate analysis and visualisation of multi-omics data, making optimal use of the computing capabilities offered by modern multi-core architectures, combined with the versatile and well known R environment for statistical analysis and data visualisation.

@incollection{15:lnbi:nuchaRt,
abstract = {Recent advances in molecular biology and Bioinformatics techniques brought to an explosion of the information about the spatial organisation of the DNA in the nucleus. High-throughput chromosome conformation capture techniques provide a genome-wide capture of chromatin contacts at unprecedented scales, which permit to identify physical interactions between genetic elements located throughout the human genome. These important studies are hampered by the lack of biologists-friendly software. In this work we present NuchaRt, an R package that wraps NuChart-II, an efficient and highly optimized C++ tool for the exploration of Hi-C data. By rising the level of abstraction, NuchaRt proposes a high-performance pipeline that allows users to orchestrate analysis and visualisation of multi-omics data, making optimal use of the computing capabilities offered by modern multi-core architectures, combined with the versatile and well known R environment for statistical analysis and data visualisation.},
author = {Fabio Tordini and Ivan Merelli and Pietro Li{\o} and Luciano Milanesi and Marco Aldinucci},
booktitle = {Computational Intelligence Methods for Bioinformatics and Biostatistics},
doi = {10.1007/978-3-319-44332-4},
editor = {Springer International Publishing},
isbn = {978-3-319-44331-7},
keywords = {fastflow, bioinformatics, repara, interomics, mimomics},
pages = {259--272},
publisher = {Springer International Publishing},
series = {{Lecture Notes in Computer Science}},
title = {{NuchaRt}: embedding high-level parallel computing in {R} for augmented {Hi-C} data analysis},
url = {https://iris.unito.it/retrieve/handle/2318/1608281/253372/rnuchart.pdf},
volume = {9874},
year = {2016},
bdsk-url-2 = {http://dx.doi.org/10.1007/978-3-319-44332-4}
}

• A. Bracciali, M. Aldinucci, M. Patterson, T. Marschall, N. Pisanti, I. Merelli, and M. Torquati, “Pwhatshap: efficient haplotyping for future generation sequencing,” Bmc bioinformatics, vol. 17, iss. Suppl 11, p. 342, 2016. doi:10.1186/s12859-016-1170-y

Background: Haplotype phasing is an important problem in the analysis of genomics information. Given a set of DNA fragments of an individual, it consists of determining which one of the possible alleles (alternative forms of a gene) each fragment comes from. Haplotype information is relevant to gene regulation, epigenetics, genome-wide association studies, evolutionary and population studies, and the study of mutations. Haplotyping is currently addressed as an optimisation problem aiming at solutions that minimise, for instance, error correction costs, where costs are a measure of the confidence in the accuracy of the information acquired from DNA sequencing. Solutions have typically an exponential computational complexity. WhatsHap is a recent optimal approach which moves computational complexity from DNA fragment length to fragment overlap, i.e., coverage, and is hence of particular interest when considering sequencing technology’s current trends that are producing longer fragments. Results: Given the potential relevance of efficient haplotyping in several analysis pipelines, we have designed and engineered pWhatsHap, a parallel, high-performance version of WhatsHap. pWhatsHap is embedded in a toolkit developed in Python and supports genomics datasets in standard file formats. Building on WhatsHap, pWhatsHap exhibits the same complexity exploring a number of possible solutions which is exponential in the coverage of the dataset. The parallel implementation on multi-core architectures allows for a relevant reduction of the execution time for haplotyping, while the provided results enjoy the same high accuracy as that provided by WhatsHap, which increases with coverage. Conclusions: Due to its structure and management of the large datasets, the parallelisation of WhatsHap posed demanding technical challenges, which have been addressed exploiting a high-level parallel programming framework. The result, pWhatsHap, is a freely available toolkit that improves the efficiency of the analysis of genomics information.

@article{16:pwhatshap:bmc,
abstract = {Background: Haplotype phasing is an important problem in the analysis of genomics information. Given a set of DNA fragments of an individual, it consists of determining which one of the possible alleles (alternative forms of a gene) each fragment comes from. Haplotype information is relevant to gene regulation, epigenetics, genome-wide association studies, evolutionary and population studies, and the study of mutations. Haplotyping is currently addressed as an optimisation problem aiming at solutions that minimise, for instance, error correction costs, where costs are a measure of the confidence in the accuracy of the information acquired from DNA sequencing. Solutions have typically an exponential computational complexity. WhatsHap is a recent optimal approach which moves computational complexity from DNA fragment length to fragment overlap, i.e., coverage, and is hence of particular interest when considering sequencing technology's current trends that are producing longer fragments.
Results: Given the potential relevance of efficient haplotyping in several analysis pipelines, we have designed and engineered pWhatsHap, a parallel, high-performance version of WhatsHap. pWhatsHap is embedded in a toolkit developed in Python and supports genomics datasets in standard file formats. Building on WhatsHap, pWhatsHap exhibits the same complexity exploring a number of possible solutions which is exponential in the coverage of the dataset. The parallel implementation on multi-core architectures allows for a relevant reduction of the execution time for haplotyping, while the provided results enjoy the same high accuracy as that provided by WhatsHap, which increases with coverage.
Conclusions: Due to its structure and management of the large datasets, the parallelisation of WhatsHap posed demanding technical challenges, which have been addressed exploiting a high-level parallel programming framework. The result, pWhatsHap, is a freely available toolkit that improves the efficiency of the analysis of genomics information.
},
author = {Andrea Bracciali and Marco Aldinucci and Murray Patterson and Tobias Marschall and Nadia Pisanti and Ivan Merelli and Massimo Torquati},
date-modified = {2016-10-17 17:28:27 +0000},
doi = {10.1186/s12859-016-1170-y},
journal = {BMC Bioinformatics},
keywords = {fastflow, paraphrase, rephrase},
number = {Suppl 11},
pages = {342},
title = {pWhatsHap: efficient haplotyping for future generation sequencing},
url = {http://bmcbioinformatics.biomedcentral.com/track/pdf/10.1186/s12859-016-1170-y?site=bmcbioinformatics.biomedcentral.com},
volume = {17},
year = {2016},
bdsk-url-1 = {http://hdl.handle.net/2318/1607125},
bdsk-url-2 = {http://bmcbioinformatics.biomedcentral.com/track/pdf/10.1186/s12859-016-1170-y?site=bmcbioinformatics.biomedcentral.com},
bdsk-url-3 = {http://dx.doi.org/10.1186/s12859-016-1170-y}
}

• F. Tordini, M. Aldinucci, L. Milanesi, P. Liò, and I. Merelli, “The genome conformation as an integrator of multi-omic data: the example of damage spreading in cancer,” Frontiers in genetics, vol. 7, iss. 194, p. 1–17, 2016. doi:10.3389/fgene.2016.00194

Publicly available multi-omic databases, in particular if associated with medical annotations, are rich resources with the potential to lead a rapid transition from high-throughput molecular biology experiments to better clinical outcomes for patients. In this work, we propose a model for multi-omic data integration (i.e. genetic variations, gene expression, genome conformation and epigenetic patterns), which exploits a multi-layer network approach to analyse, visualize and obtain insights from such biological information, in order to use achieved results at a macroscopic level. Using this representation, we can describe how driver and passenger mutations accumulate during the development of diseases providing, for example, a tool able to characterise the evolution of cancer. Indeed, our test case concerns the MCF-7 breast cancer cell line, before and after the stimulation with estrogen, since many datasets are available for this case study. In particular, the integration of data about cancer mutations, gene functional annotations, genome conformation, epigenetic patterns, gene expression and metabolic pathways in our multi-layer representation will allow a better interpretation of the mechanisms behind a complex disease such as cancer. Thanks to this multi-layer approach, we focus on the interplay of chromatin conformation and cancer mutations in different pathways, such as metabolic processes, that are very important for tumour development. Working on this model, a variance analysis can be implemented to identify normal variations within each omics and to characterize, by contrast, variations that can be accounted to pathological samples compared to normal ones. This integrative model can be used to identify novel biomarkers and to provide innovative omic-based guidelines for treating many diseases, improving the efficacy of decision trees currently used in clinic.

@article{2016_omics_fgenetics,
abstract = {Publicly available multi-omic databases, in particular if associated with medical annotations, are rich resources with the potential to lead a rapid transition from high-throughput molecular biology experiments to better clinical outcomes for patients. In this work, we propose a model for multi-omic data integration (i.e. genetic variations, gene expression, genome conformation and epigenetic patterns), which exploits a multi-layer network approach to analyse, visualize and obtain insights from such biological information, in order to use achieved results at a macroscopic level.
Using this representation, we can describe how driver and passenger mutations accumulate during the development of diseases providing, for example, a tool able to characterise the evolution of cancer. Indeed, our test case concerns the MCF-7 breast cancer cell line, before and after the stimulation with estrogen, since many datasets are available for this case study. In particular, the integration of data about cancer mutations, gene functional annotations, genome conformation, epigenetic patterns, gene expression and metabolic pathways in our multi-layer representation will allow a better interpretation of the mechanisms behind a complex disease such as cancer.
Thanks to this multi-layer approach, we focus on the interplay of chromatin conformation and cancer mutations in different pathways, such as metabolic processes, that are very important for tumour development. Working on this model, a variance analysis can be implemented to identify normal variations within each omics and to characterize, by contrast, variations that can be accounted to pathological samples compared to normal ones. This integrative model can be used to identify novel biomarkers and to provide innovative omic-based guidelines for treating many diseases, improving the efficacy of decision trees currently used in clinic.},
author = {Tordini, Fabio and Aldinucci, Marco and Milanesi, Luciano and Li{\o}, Pietro and Merelli, Ivan},
date-modified = {2016-12-22 14:19:14 +0000},
doi = {10.3389/fgene.2016.00194},
journal = {Frontiers in Genetics},
number = {194},
pages = {1--17},
title = {The Genome Conformation as an Integrator of Multi-Omic Data: The Example of Damage Spreading in Cancer},
url = {http://journal.frontiersin.org/article/10.3389/fgene.2016.00194},
volume = {7},
year = {2016},
bdsk-url-1 = {http://journal.frontiersin.org/article/10.3389/fgene.2016.00194},
bdsk-url-2 = {http://dx.doi.org/10.3389/fgene.2016.00194}
}

### 2015

• M. Aldinucci, M. Danelutto, M. Drocco, P. Kilpatrick, G. Peretti Pezzi, and M. Torquati, “The loop-of-stencil-reduce paradigm,” in Proc. of intl. workshop on reengineering for parallelism in heterogeneous parallel platforms (repara), Helsinki, Finland, 2015, pp. 172-177. doi:10.1109/Trustcom.2015.628

In this paper we advocate the Loop-of-stencil-reduce pattern as a way to simplify the parallel programming of heterogeneous platforms (multicore+GPUs). Loop-of-Stencil-reduce is general enough to subsume map, reduce, map-reduce, stencil, stencil-reduce, and, crucially, their usage in a loop. It transparently targets (by using OpenCL) combinations of CPU cores and GPUs, and it makes it possible to simplify the deployment of a single stencil computation kernel on different GPUs. The paper discusses the implementation of Loop-of-stencil-reduce within the FastFlow parallel framework, considering a simple iterative data-parallel application as running example (Game of Life) and a highly effective parallel filter for visual data restoration to assess performance. Thanks to the high-level design of the Loop-of-stencil-reduce, it was possible to run the filter seamlessly on a multicore machine, on multi-GPUs, and on both.

@inproceedings{opencl:ff:ispa:15,
abstract = {In this paper we advocate the Loop-of-stencil-reduce pattern as a way to simplify the parallel programming of heterogeneous platforms (multicore+GPUs). Loop-of-Stencil-reduce is general enough to subsume map, reduce, map-reduce, stencil, stencil-reduce, and, crucially, their usage in a loop. It transparently targets (by using OpenCL) combinations of CPU cores and GPUs, and it makes it possible to simplify the deployment of a single stencil computation kernel on different GPUs. The paper discusses the implementation of Loop-of-stencil-reduce within the FastFlow parallel framework, considering a simple iterative data-parallel application as running example (Game of Life) and a highly effective parallel filter for visual data restoration to assess performance. Thanks to the high-level design of the Loop-of-stencil-reduce, it was possible to run the filter seamlessly on a multicore machine, on multi-GPUs, and on both.},
author = {Marco Aldinucci and Marco Danelutto and Maurizio Drocco and Peter Kilpatrick and Guilherme {Peretti Pezzi} and Massimo Torquati},
booktitle = {Proc. of Intl. Workshop on Reengineering for Parallelism in Heterogeneous Parallel Platforms (RePara)},
date-modified = {2015-09-24 11:14:56 +0000},
doi = {10.1109/Trustcom.2015.628},
keywords = {fastflow, repara, nvidia},
month = aug,
pages = {172-177},
publisher = {IEEE},
url = {https://iris.unito.it/retrieve/handle/2318/1523738/52857/15_RePara_ISPA.pdf},
year = {2015},
bdsk-url-1 = {https://iris.unito.it/retrieve/handle/2318/1523738/52857/15_RePara_ISPA.pdf},
bdsk-url-2 = {https://doi.org/10.1109/Trustcom.2015.628}
}

• F. Tordini, M. Drocco, I. Merelli, L. Milanesi, P. Liò, and M. Aldinucci, “NuChart-II: a graph-based approach for the analysis and interpretation of Hi-C data,” in Proc. of 11th intl. meeting on computational intelligence methods for bioinformatics and biostatistics (cibb), Cambridge, UK, 2015, pp. 298-311. doi:10.1007/978-3-319-24462-4_25

Long-range chromosomal associations between genomic regions, and their repositioning in the 3D space of the nucleus, are now considered to be key contributors to the regulation of gene expressions, and important links have been highlighted with other genomic features involved in DNA rearrangements. Recent Chromosome Conformation Capture (3C) measurements performed with high throughput sequencing (Hi-C) and molecular dynamics studies show that there is a large correlation between co-localization and co-regulation of genes, but these important researches are hampered by the lack of biologists-friendly analysis and visualisation software. In this work we present NuChart-II, a software that allows the user to annotate and visualize a list of input genes with information relying on Hi-C data, integrating knowledge data about genomic features that are involved in the chromosome spatial organization. This software works directly with sequenced reads to identify related Hi-C fragments, with the aim of creating gene-centric neighbourhood graphs on which multi-omics features can be mapped. NuChart-II is a highly optimized implementation of a previous prototype package developed in R, in which the graph-based representation of Hi-C data was tested. The prototype showed inevitable problems of scalability while working genome-wide on large datasets: particular attention has been paid in optimizing the data structures employed while constructing the neighbourhood graph, so as to foster an efficient parallel implementation of the software. The normalization of Hi-C data has been modified and improved, in order to provide a reliable estimation of proximity likelihood for the genes.

@inproceedings{14:ff:nuchart:cibb,
abstract = {Long-range chromosomal associations between genomic regions, and their repositioning in the 3D space of the nucleus, are now considered to be key contributors to the regulation of gene expressions, and important links have been highlighted with other genomic features involved in DNA rearrangements. Recent Chromosome Conformation Capture (3C) measurements performed with high throughput sequencing (Hi-C) and molecular dynamics studies show that there is a large correlation between co-localization and co-regulation of genes, but these important researches are hampered by the lack of biologists-friendly analysis and visualisation software. In this work we present NuChart-II, a software that allows the user to annotate and visualize a list of input genes with information relying on Hi-C data, integrating knowledge data about genomic features that are involved in the chromosome spatial organization. This software works directly with sequenced reads to identify related Hi-C fragments, with the aim of creating gene-centric neighbourhood graphs on which multi-omics features can be mapped. NuChart-II is a highly optimized implementation of a previous prototype package developed in R, in which the graph-based representation of Hi-C data was tested. The prototype showed inevitable problems of scalability while working genome-wide on large datasets: particular attention has been paid in optimizing the data structures employed while constructing the neighbourhood graph, so as to foster an efficient parallel implementation of the software. The normalization of Hi-C data has been modified and improved, in order to provide a reliable estimation of proximity likelihood for the genes.},
author = {Fabio Tordini and Maurizio Drocco and Ivan Merelli and Luciano Milanesi and Pietro Li{\o} and Marco Aldinucci},
booktitle = {Proc. of 11th Intl. Meeting on Computational Intelligence Methods for Bioinformatics and Biostatistics (CIBB)},
date-modified = {2017-12-12 15:19:25 +0000},
doi = {10.1007/978-3-319-24462-4_25},
editor = {Clelia Di Serio and Pietro Li{\{o}} and Alessandro Nonis and Roberto Tagliaferri},
isbn = {978-3-319-24461-7},
keywords = {fastflow, bioinformatics, paraphrase, repara, interomics, mimomics, hirma},
month = jun,
pages = {298-311},
publisher = {Springer},
series = {{LNCS}},
title = {{NuChart-II}: a graph-based approach for the analysis and interpretation of {Hi-C} data},
volume = {8623},
year = {2015},
bdsk-url-2 = {http://dx.doi.org/10.1007/978-3-319-24462-4_25}
}

• M. Drocco, C. Misale, G. Peretti Pezzi, F. Tordini, and M. Aldinucci, “Memory-optimised parallel processing of Hi-C data,” in Proc. of 23rd euromicro intl. conference on parallel distributed and network-based processing (pdp), 2015, pp. 1-8. doi:10.1109/PDP.2015.63

This paper presents the optimisation efforts on the creation of a graph-based mapping representation of gene adjacency. The method is based on the Hi-C process, starting from Next Generation Sequencing data, and it analyses a huge amount of static data in order to produce maps for one or more genes. Straightforward parallelisation of this scheme does not yield acceptable performance on multicore architectures since the scalability is rather limited due to the memory bound nature of the problem. This work focuses on the memory optimisations that can be applied to the graph construction algorithm and its (complex) data structures to derive a cache-oblivious algorithm and eventually to improve the memory bandwidth utilisation. We used as running example NuChart-II, a tool for annotation and statistic analysis of Hi-C data that creates a gene-centric neighborhood graph. The proposed approach, which is exemplified for Hi-C, addresses several common issue in the parallelisation of memory bound algorithms for multicore. Results show that the proposed approach is able to increase the parallel speedup from 7x to 22x (on a 32-core platform). Finally, the proposed C++ implementation outperforms the first R NuChart prototype, by which it was not possible to complete the graph generation because of strong memory-saturation problems.

@inproceedings{nuchart:speedup:15,
abstract = {This paper presents the optimisation efforts on the creation of a graph-based mapping representation of gene adjacency. The method is based on the Hi-C process, starting from Next Generation Sequencing data, and it analyses a huge amount of static data in order to produce maps for one or more genes. Straightforward parallelisation of this scheme does not yield acceptable performance on multicore architectures since the scalability is rather limited due to the memory bound nature of the problem. This work focuses on the memory optimisations that can be applied to the graph construction algorithm and its (complex) data structures to derive a cache-oblivious algorithm and eventually to improve the memory bandwidth utilisation. We used as running example NuChart-II, a tool for annotation and statistic analysis of Hi-C data that creates a gene-centric neighborhood graph. The proposed approach, which is exemplified for Hi-C, addresses several common issue in the parallelisation of memory bound algorithms for multicore. Results show that the proposed approach is able to increase the parallel speedup from 7x to 22x (on a 32-core platform). Finally, the proposed C++ implementation outperforms the first R NuChart prototype, by which it was not possible to complete the graph generation because of strong memory-saturation problems.},
author = {Maurizio Drocco and Claudia Misale and Guilherme {Peretti Pezzi} and Fabio Tordini and Marco Aldinucci},
booktitle = {Proc. of 23rd Euromicro Intl. Conference on Parallel Distributed and network-based Processing (PDP)},
date-modified = {2017-12-12 14:45:09 +0000},
doi = {10.1109/PDP.2015.63},
keywords = {fastflow,bioinformatics, paraphrase, repara, impact},
month = mar,
pages = {1-8},
publisher = {IEEE},
title = {Memory-Optimised Parallel Processing of {Hi-C} Data},
url = {https://iris.unito.it/retrieve/handle/2318/1521910/40615/2015_pdp_memopt.pdf},
year = {2015},
bdsk-url-1 = {https://iris.unito.it/retrieve/handle/2318/1521910/40615/2015_pdp_memopt.pdf},
bdsk-url-2 = {https://doi.org/10.1109/PDP.2015.63}
}

• F. Tordini, M. Drocco, C. Misale, L. Milanesi, P. Liò, I. Merelli, and M. Aldinucci, “Parallel exploration of the nuclear chromosome conformation with NuChart-II,” in Proc. of 23rd euromicro intl. conference on parallel distributed and network-based processing (pdp), 2015. doi:10.1109/PDP.2015.104

High-throughput molecular biology techniques are widely used to identify physical interactions between genetic elements located throughout the human genome. Chromosome Conformation Capture (3C) and other related techniques allow to investigate the spatial organisation of chromosomes in the cell’s natural state. Recent results have shown that there is a large correlation between co-localization and co-regulation of genes, but these important information are hampered by the lack of biologists-friendly analysis and visualisation software. In this work we introduce NuChart-II, a tool for Hi-C data analysis that provides a gene-centric view of the chromosomal neighbour- hood in a graph-based manner. NuChart-II is an efficient and highly optimized C++ re-implementation of a previous prototype package developed in R. Representing Hi-C data using a graph-based approach overcomes the common view relying on genomic coordinates and permits the use of graph analysis techniques to explore the spatial conformation of a gene neighbourhood.

@inproceedings{nuchar:tool:15,
abstract = {High-throughput molecular biology techniques are widely used to identify physical interactions between genetic elements located throughout the human genome. Chromosome Conformation Capture (3C) and other related techniques allow to investigate the spatial organisation of chromosomes in the cell's natural state. Recent results have shown that there is a large correlation between co-localization and co-regulation of genes, but these important information are hampered by the lack of biologists-friendly analysis and visualisation software. In this work we introduce NuChart-II, a tool for Hi-C data analysis that provides a gene-centric view of the chromosomal neighbour- hood in a graph-based manner. NuChart-II is an efficient and highly optimized C++ re-implementation of a previous prototype package developed in R. Representing Hi-C data using a graph-based approach overcomes the common view relying on genomic coordinates and permits the use of graph analysis techniques to explore the spatial conformation of a gene neighbourhood.
},
author = {Fabio Tordini and Maurizio Drocco and Claudia Misale and Luciano Milanesi and Pietro Li{\o} and Ivan Merelli and Marco Aldinucci},
booktitle = {Proc. of 23rd Euromicro Intl. Conference on Parallel Distributed and network-based Processing (PDP)},
date-modified = {2017-12-12 13:55:10 +0000},
doi = {10.1109/PDP.2015.104},
keywords = {fastflow, bioinformatics, paraphrase, repara, impact},
month = mar,
publisher = {IEEE},
title = {Parallel Exploration of the Nuclear Chromosome Conformation with {NuChart-II}},
url = {https://iris.unito.it/retrieve/handle/2318/1522038/40619/2015_pdp_nuchartff.pdf},
year = {2015},
bdsk-url-1 = {https://iris.unito.it/retrieve/handle/2318/1522038/40619/2015_pdp_nuchartff.pdf},
bdsk-url-2 = {https://doi.org/10.1109/PDP.2015.104}
}

• I. Merelli, F. Tordini, M. Drocco, M. Aldinucci, P. Liò, and L. Milanesi, “Integrating multi-omic features exploiting Chromosome Conformation Capture data,” Frontiers in genetics, vol. 6, iss. 40, 2015. doi:10.3389/fgene.2015.00040

The representation, integration and interpretation of omic data is a complex task, in particular considering the huge amount of information that is daily produced in molecular biology laboratories all around the world. The reason is that sequencing data regarding expression profiles, methylation patterns, and chromatin domains is difficult to harmonize in a systems biology view, since genome browsers only allow coordinate-based representations, discarding functional clusters created by the spatial conformation of the DNA in the nucleus. In this context, recent progresses in high throughput molecular biology techniques and bioinformatics have provided insights into chromatin interactions on a larger scale and offer a formidable support for the interpretation of multi-omic data. In particular, a novel sequencing technique called Chromosome Conformation Capture (3C) allows the analysis of the chromosome organization in the cell’s natural state. While performed genome wide, this technique is usually called Hi-C. Inspired by service applications such as Google Maps, we developed NuChart, an R package that integrates Hi-C data to describe the chromosomal neighbourhood starting from the information about gene positions, with the possibility of mapping on the achieved graphs genomic features such as methylation patterns and histone modifications, along with expression profiles. In this paper we show the importance of the NuChart application for the integration of multi-omic data in a systems biology fashion, with particular interest in cytogenetic applications of these techniques. Moreover, we demonstrate how the integration of multi-omic data can provide useful information in understanding why genes are in certain specific positions inside the nucleus and how epigenetic patterns correlate with their expression.

@article{nuchart:frontiers:15,
abstract = {The representation, integration and interpretation of omic data is a complex task, in particular considering the huge amount of information that is daily produced in molecular biology laboratories all around the world. The reason is that sequencing data regarding expression profiles, methylation patterns, and chromatin domains is difficult to harmonize in a systems biology view, since genome browsers only allow coordinate-based representations, discarding functional clusters created by the spatial conformation of the DNA in the nucleus. In this context, recent progresses in high throughput molecular biology techniques and bioinformatics have provided insights into chromatin interactions on a larger scale and offer a formidable support for the interpretation of multi-omic data. In particular, a novel sequencing technique called Chromosome Conformation Capture (3C) allows the analysis of the chromosome organization in the cell's natural state. While performed genome wide, this technique is usually called Hi-C. Inspired by service applications such as Google Maps, we developed NuChart, an R package that integrates Hi-C data to describe the chromosomal neighbourhood starting from the information about gene positions, with the possibility of mapping on the achieved graphs genomic features such as methylation patterns and histone modifications, along with expression profiles. In this paper we show the importance of the NuChart application for the integration of multi-omic data in a systems biology fashion, with particular interest in cytogenetic applications of these techniques. Moreover, we demonstrate how the integration of multi-omic data can provide useful information in understanding why genes are in certain specific positions inside the nucleus and how epigenetic patterns correlate with their expression.},
author = {Merelli, Ivan and Tordini, Fabio and Drocco, Maurizio and Aldinucci, Marco and Li{\o}, Pietro and Milanesi, Luciano},
date-modified = {2015-09-24 11:23:10 +0000},
doi = {10.3389/fgene.2015.00040},
issn = {1664-8021},
journal = {Frontiers in Genetics},
keywords = {bioinformatics, fastflow, interomics, hirma, mimomics},
number = {40},
title = {Integrating Multi-omic features exploiting {Chromosome Conformation Capture} data},
url = {http://journal.frontiersin.org/Journal/10.3389/fgene.2015.00040/pdf},
volume = {6},
year = {2015},
bdsk-url-1 = {http://journal.frontiersin.org/Journal/10.3389/fgene.2015.00040/pdf},
bdsk-url-2 = {http://dx.doi.org/10.3389/fgene.2015.00040}
}

• M. Aldinucci, A. Bracciali, T. Marschall, M. Patterson, N. Pisanti, and M. Torquati, “High-performance haplotype assembly,” in Computational intelligence methods for bioinformatics and biostatistics – 11th international meeting, CIBB 2014, cambridge, uk, june 26-28, 2014, revised selected papers, Cambridge, UK, 2015, p. 245–258. doi:10.1007/978-3-319-24462-4_21

The problem of Haplotype Assembly is an essential step in human genome analysis. It is typically formalised as the Minimum Error Correction (MEC) problem which is NP-hard. MEC has been approached using heuristics, integer linear programming, and fixed-parameter tractability (FPT), including approaches whose runtime is exponential in the length of the DNA fragments obtained by the sequencing process. Technological improvements are currently increasing fragment length, which drastically elevates computational costs for such methods. We present pWhatsHap, a multi-core parallelisation of WhatsHap, a recent FPT optimal approach to MEC. WhatsHap moves complexity from fragment length to fragment overlap and is hence of particular interest when considering sequencing technology’s current trends. pWhatsHap further improves the efficiency in solving the MEC problem, as shown by experiments performed on datasets with high coverage.

@inproceedings{14:ff:whatsapp:cibb,
abstract = {The problem of Haplotype Assembly is an essential step in human genome analysis. It is typically formalised as the Minimum Error Correction (MEC) problem which is NP-hard. MEC has been approached using heuristics, integer linear programming, and fixed-parameter tractability (FPT), including approaches whose runtime is exponential in the length of the DNA fragments obtained by the sequencing process. Technological improvements are currently increasing fragment length, which drastically elevates computational costs for such methods. We present pWhatsHap, a multi-core parallelisation of WhatsHap, a recent FPT optimal approach to MEC. WhatsHap moves complexity from fragment length to fragment overlap and is hence of particular interest when considering sequencing technology's current trends. pWhatsHap further improves the efficiency in solving the MEC problem, as shown by experiments performed on datasets with high coverage.},
author = {Marco Aldinucci and Andrea Bracciali and Tobias Marschall and Murray Patterson and Nadia Pisanti and Massimo Torquati},
booktitle = {Computational Intelligence Methods for Bioinformatics and Biostatistics - 11th International Meeting, {CIBB} 2014, Cambridge, UK, June 26-28, 2014, Revised Selected Papers},
date-modified = {2016-08-20 14:15:59 +0000},
doi = {10.1007/978-3-319-24462-4_21},
editor = {Clelia Di Serio and Pietro Li{\{o}} and Alessandro Nonis and Roberto Tagliaferri},
keywords = {fastflow, bioinformatics},
pages = {245--258},
publisher = {Springer},
series = {{LNCS}},
title = {High-Performance Haplotype Assembly},
url = {https://iris.unito.it/retrieve/handle/2318/1523292/46714/2014_pHaplo_cibb.pdf},
volume = {8623},
year = {2015},
bdsk-url-1 = {https://iris.unito.it/retrieve/handle/2318/1523292/46714/2014_pHaplo_cibb.pdf},
bdsk-url-2 = {https://doi.org/10.1007/978-3-319-24462-4_21}
}

• M. Aldinucci, G. Peretti Pezzi, M. Drocco, C. Spampinato, and M. Torquati, “Parallel visual data restoration on multi-GPGPUs using stencil-reduce pattern,” International journal of high performance computing applications, vol. 29, iss. 4, pp. 461-472, 2015. doi:10.1177/1094342014567907

In this paper, a highly effective parallel filter for visual data restoration is presented. The filter is designed following a skeletal approach, using a newly proposed stencil-reduce, and has been implemented by way of the FastFlow parallel programming library. As a result of its high-level design, it is possible to run the filter seamlessly on a multicore machine, on multi-GPGPUs, or on both. The design and implementation of the filter are discussed, and an experimental evaluation is presented.

@article{ff:denoiser:ijhpca:15,
abstract = {In this paper, a highly effective parallel filter for visual data restoration is presented. The filter is designed following a skeletal approach, using a newly proposed stencil-reduce, and has been implemented by way of the FastFlow parallel programming library. As a result of its high-level design, it is possible to run the filter seamlessly on a multicore machine, on multi-GPGPUs, or on both. The design and implementation of the filter are discussed, and an experimental evaluation is presented.},
author = {Marco Aldinucci and Guilherme {Peretti Pezzi} and Maurizio Drocco and Concetto Spampinato and Massimo Torquati},
date-modified = {2015-09-24 11:21:20 +0000},
doi = {10.1177/1094342014567907},
journal = {International Journal of High Performance Computing Applications},
keywords = {fastflow, paraphrase, impact, nvidia},
number = {4},
pages = {461-472},
title = {Parallel Visual Data Restoration on Multi-{GPGPUs} using Stencil-Reduce Pattern},
url = {https://iris.unito.it/retrieve/handle/2318/1522073/299200/ijhpca_4aperto.pdf},
volume = {29},
year = {2015},
bdsk-url-1 = {https://iris.unito.it/retrieve/handle/2318/1522073/299200/ijhpca_4aperto.pdf},
bdsk-url-2 = {https://doi.org/10.1177/1094342014567907}
}

### 2014

• M. G. Epitropakis, A. Bracciali, M. Aldinucci, E. Potts, and E. K. Burke, “Predictive scheduling for optimal cloud configuration,” in Proc. of 10th intl. conference on the practice and theory of automated timetabling, York, United Kingdom, 2014. doi:978-0-9929984-0-0
@inproceedings{cloud:patat:14,
author = {Michael G. Epitropakis and Andrea Bracciali and Marco Aldinucci and Emily Potts and Edmund K. Burke},
booktitle = {Proc. of 10th Intl. Conference on the Practice and Theory of Automated Timetabling},
date-modified = {2021-03-26 23:55:53 +0100},
doi = {978-0-9929984-0-0},
editor = {Ender {\"O}zcan and Edmund K. Burke and Barry MCCollum},
month = aug,
publisher = {PATAT},
title = {Predictive scheduling for optimal cloud configuration},
url = {http://www.patatconference.org/patat2014/proceedings/3_12.pdf},
year = {2014},
bdsk-url-1 = {http://www.patatconference.org/patat2014/proceedings/3_12.pdf}
}

• M. Aldinucci, S. Campa, M. Danelutto, P. Kilpatrick, and M. Torquati, “Pool evolution: a domain specific parallel pattern,” in Proc.of the 7th intl. symposium on high-level parallel programming and applications (hlpp), Amsterdam, The Netherlands, 2014.

We introduce a new parallel pattern derived from a specific application domain and show how it turns out to have application beyond its domain of origin. The pool evolution pattern models the parallel evolution of a population subject to mutations and evolving in such a way that a given fitness function is optimized. The pattern has been demonstrated to be suitable for capturing and modeling the parallel patterns underpinning various evolutionary algorithms, as well as other parallel patterns typical of symbolic computation. In this paper we introduce the pattern, developed in the framework of the ParaPhrase EU-funded FP7 project, we discuss its implementation on modern multi/many core architectures and finally present experimental results obtained with FastFlow and Erlang implementations to assess its feasibility and scalability.

@inproceedings{2014:ff:pool:hlpp,
abstract = {We introduce a new parallel pattern derived from a specific application domain and show how it turns out to have application beyond its domain of origin. The pool evolution pattern models the parallel evolution of a population subject to mutations and evolving in such a way that a given fitness function is optimized. The pattern has been demonstrated to be suitable for capturing and modeling the parallel patterns underpinning various evolutionary algorithms, as well as other parallel patterns typical of symbolic computation. In this paper we introduce the pattern, developed in the framework of the ParaPhrase EU-funded FP7 project, we discuss its implementation on modern multi/many core architectures and finally present experimental results obtained with FastFlow and Erlang implementations to assess its feasibility and scalability.},
author = {Marco Aldinucci and Sonia Campa and Marco Danelutto and Peter Kilpatrick and Massimo Torquati},
booktitle = {Proc.of the 7th Intl. Symposium on High-level Parallel Programming and Applications (HLPP)},
date-modified = {2015-09-27 12:14:30 +0000},
keywords = {fastflow, paraphrase, repara},
month = jul,
title = {Pool evolution: a domain specific parallel pattern},
year = {2014},
}

• M. Aldinucci, M. Torquati, M. Drocco, G. Peretti Pezzi, and C. Spampinato, “Fastflow: combining pattern-level abstraction and efficiency in GPGPUs,” in Gpu technology conference (gtc), San Jose, CA, USA, 2014.

Learn how FastFlow’s parallel patterns can be used to design parallel applications for execution on both CPUs and GPGPUs while avoiding most of the complex low-level detail needed to make them efficient, portable and rapid to prototype. As use case, we will show the design and effectiveness of a novel universal image filtering template based on the variational approach.

@inproceedings{ff:gtc:2014,
abstract = {Learn how FastFlow's parallel patterns can be used to design parallel applications for execution on both CPUs and GPGPUs while avoiding most of the complex low-level detail needed to make them efficient, portable and rapid to prototype. As use case, we will show the design and effectiveness of a novel universal image filtering template based on the variational approach.},
address = {San Jose, CA, USA},
author = {Marco Aldinucci and Massimo Torquati and Maurizio Drocco and Guilherme {Peretti Pezzi} and Concetto Spampinato},
booktitle = {GPU Technology Conference (GTC)},
date-modified = {2017-12-12 13:54:25 +0000},
keywords = {fastflow, gpu, nvidia, impact, paraphrase},
month = mar,
title = {FastFlow: Combining Pattern-Level Abstraction and Efficiency in {GPGPUs}},
year = {2014},
}

• M. Aldinucci, M. Torquati, M. Drocco, G. Peretti Pezzi, and C. Spampinato, “An overview of fastflow: combining pattern-level abstraction and efficiency in GPGPUs,” in Gpu technology conference (gtc), San Jose, CA, USA, 2014.

Get an overview of FastFlow’s parallel patterns can be used to design parallel applications for execution on both CPUs and GPGPUs while avoiding most of the complex low-level detail needed to make them efficient, portable and rapid to prototype. For a more detailed and technical review of FastFlow’s parallel patterns as well as a use case where we will show the design and effectiveness of a novel universal image filtering template based on the variational approach.

@inproceedings{ff:gtc:2014:short,
abstract = {Get an overview of FastFlow's parallel patterns can be used to design parallel applications for execution on both CPUs and GPGPUs while avoiding most of the complex low-level detail needed to make them efficient, portable and rapid to prototype. For a more detailed and technical review of FastFlow's parallel patterns as well as a use case where we will show the design and effectiveness of a novel universal image filtering template based on the variational approach.},
address = {San Jose, CA, USA},
author = {Marco Aldinucci and Massimo Torquati and Maurizio Drocco and Guilherme {Peretti Pezzi} and Concetto Spampinato},
booktitle = {GPU Technology Conference (GTC)},
date-modified = {2017-12-12 13:54:20 +0000},
keywords = {fastflow, gpu, nvidia, impact, paraphrase},
month = mar,
title = {An Overview of FastFlow: Combining Pattern-Level Abstraction and Efficiency in {GPGPUs}},
year = {2014},
}

• M. Aldinucci, M. Torquati, C. Spampinato, M. Drocco, C. Misale, C. Calcagno, and M. Coppo, “Parallel stochastic systems biology in the cloud,” Briefings in bioinformatics, vol. 15, iss. 5, pp. 798-813, 2014. doi:10.1093/bib/bbt040

The stochastic modelling of biological systems, coupled with Monte Carlo simulation of models, is an increasingly popular technique in bioinformatics. The simulation-analysis workflow may result computationally expensive reducing the interactivity required in the model tuning. In this work, we advocate the high-level software design as a vehicle for building efficient and portable parallel simulators for the cloud. In particular, the Calculus of Wrapped Components (CWC) simulator for systems biology, which is designed according to the FastFlow pattern-based approach, is presented and discussed. Thanks to the FastFlow framework, the CWC simulator is designed as a high-level workflow that can simulate CWC models, merge simulation results and statistically analyse them in a single parallel workflow in the cloud. To improve interactivity, successive phases are pipelined in such a way that the workflow begins to output a stream of analysis results immediately after simulation is started. Performance and effectiveness of the CWC simulator are validated on the Amazon Elastic Compute Cloud.

@article{cwc:cloud:bib:13,
abstract = {The stochastic modelling of biological systems, coupled with Monte Carlo simulation of models, is an increasingly popular technique in bioinformatics. The simulation-analysis workflow may result computationally expensive reducing the interactivity required in the model tuning. In this work, we advocate the high-level software design as a vehicle for building efficient and portable parallel simulators for the cloud. In particular, the Calculus of Wrapped Components (CWC) simulator for systems biology, which is designed according to the FastFlow pattern-based approach, is presented and discussed. Thanks to the FastFlow framework, the CWC simulator is designed as a high-level workflow that can simulate CWC models, merge simulation results and statistically analyse them in a single parallel workflow in the cloud. To improve interactivity, successive phases are pipelined in such a way that the workflow begins to output a stream of analysis results immediately after simulation is started. Performance and effectiveness of the CWC simulator are validated on the Amazon Elastic Compute Cloud.},
author = {Marco Aldinucci and Massimo Torquati and Concetto Spampinato and Maurizio Drocco and Claudia Misale and Cristina Calcagno and Mario Coppo},
date-modified = {2021-04-24 23:24:25 +0200},
doi = {10.1093/bib/bbt040},
issn = {1467-5463},
journal = {Briefings in Bioinformatics},
keywords = {fastflow, bioinformatics, paraphrase, impact, biobits},
number = {5},
pages = {798-813},
title = {Parallel stochastic systems biology in the cloud},
url = {https://iris.unito.it/retrieve/handle/2318/140080/22528/FF_Cloud_briefings_final_submitted_copy.pdf},
volume = {15},
year = {2014},
bdsk-url-1 = {https://iris.unito.it/retrieve/handle/2318/140080/22528/FF_Cloud_briefings_final_submitted_copy.pdf},
bdsk-url-2 = {https://doi.org/10.1093/bib/bbt040}
}

• C. Spampinato, I. Kavasidis, M. Aldinucci, C. Pino, D. Giordano, and A. Faro, “Discovering biological knowledge by integrating high throughput data and scientific literature on the cloud,” Concurrency and computation: practice and experience, vol. 26, iss. 10, pp. 1771-1786, 2014. doi:10.1002/cpe.3130

In this paper, we present a bioinformatics knowledge discovery tool for extracting and validating associations between biological entities. By mining specialised scientific literature, the tool not only generates biological hypotheses in the form of associations between genes, proteins, miRNA and diseases, but also validates the plausibility of such associations against high-throughput biological data (e.g. microarray) and annotated databases (e.g. Gene Ontology). Both the knowledge discovery system and its validation are carried out by exploiting the advantages and the potentialities of the Cloud, which allowed us to derive and check the validity of thousands of biological associations in a reasonable amount of time. The system was tested on a dataset containing more than 1000 gene-disease associations achieving an average recall of about 71\%, outperforming existing approaches. The results also showed that porting a data-intensive application in an IaaS cloud environment boosts significantly the application’s efficiency.

@article{biocloud:ccpe:13,
abstract = {In this paper, we present a bioinformatics knowledge discovery tool for extracting and validating associations between biological entities. By mining specialised scientific literature, the tool not only generates biological hypotheses in the form of associations between genes, proteins, miRNA and diseases, but also validates the plausibility of such associations against high-throughput biological data (e.g. microarray) and annotated databases (e.g. Gene Ontology). Both the knowledge discovery system and its validation are carried out by exploiting the advantages and the potentialities of the Cloud, which allowed us to derive and check the validity of thousands of biological associations in a reasonable amount of time. The system was tested on a dataset containing more than 1000 gene-disease associations achieving an average recall of about 71\%, outperforming existing approaches. The results also showed that porting a data-intensive application in an IaaS cloud environment boosts significantly the application's efficiency.},
author = {Concetto Spampinato and Isaak Kavasidis and Marco Aldinucci and Carmelo Pino and Daniela Giordano and Alberto Faro},
date-modified = {2021-04-24 23:24:19 +0200},
doi = {10.1002/cpe.3130},
journal = {Concurrency and Computation: Practice and Experience},
number = {10},
pages = {1771-1786},
title = {Discovering Biological Knowledge by Integrating High Throughput Data and Scientific Literature on the Cloud},
url = {https://iris.unito.it/retrieve/handle/2318/139542/22526/2013_biocloud_ccpe.pdf},
volume = {26},
year = {2014},
bdsk-url-1 = {https://iris.unito.it/retrieve/handle/2318/139542/22526/2013_biocloud_ccpe.pdf},
bdsk-url-2 = {https://doi.org/10.1002/cpe.3130}
}

• M. Aldinucci, S. Campa, M. Danelutto, P. Kilpatrick, and M. Torquati, “Design patterns percolating to parallel programming framework implementation,” International journal of parallel programming, vol. 42, iss. 6, pp. 1012-1031, 2014. doi:10.1007/s10766-013-0273-6

Structured parallel programming is recognised as a viable and effective means of tackling parallel programming problems. Recently, a set of simple and powerful parallel building blocks (RISC-pb2l) has been proposed to support modelling and implementation of parallel frameworks. In this work we demonstrate how that same parallel building block set may be used to model both general purpose parallel programming abstractions, not usually listed in classical skeleton sets, and more specialized domain specific parallel patterns. We show how an implementation of RISC-pb2l can be realised via the FastFlow framework and present experimental evidence of the feasibility and efficiency of the approach.

@article{ijpp:patterns:13,
abstract = {Structured parallel programming is recognised as a viable and effective means of tackling parallel programming problems. Recently, a set of simple and powerful parallel building blocks (RISC-pb2l) has been proposed to support modelling and implementation of parallel frameworks. In this work we demonstrate how that same parallel building block set may be used to model both general purpose parallel programming abstractions, not usually listed in classical skeleton sets, and more specialized domain specific parallel patterns. We show how an implementation of RISC-pb2l can be realised via the FastFlow framework and present experimental evidence of the feasibility and efficiency of the approach.},
author = {Marco Aldinucci and Sonia Campa and Marco Danelutto and Peter Kilpatrick and Massimo Torquati},
date-modified = {2015-09-27 12:32:37 +0000},
doi = {10.1007/s10766-013-0273-6},
issn = {0885-7458},
journal = {International Journal of Parallel Programming},
keywords = {fastflow, paraphrase},
number = {6},
pages = {1012-1031},
title = {Design patterns percolating to parallel programming framework implementation},
url = {https://iris.unito.it/retrieve/handle/2318/140069/22527/2013_ijpp_patterns-web_4aperto_1238811.pdf},
volume = {42},
year = {2014},
bdsk-url-1 = {https://iris.unito.it/retrieve/handle/2318/140069/22527/2013_ijpp_patterns-web_4aperto_1238811.pdf},
bdsk-url-2 = {https://doi.org/10.1007/s10766-013-0273-6}
}

• M. Aldinucci, S. Ruggieri, and M. Torquati, “Decision tree building on multi-core using fastflow,” Concurrency and computation: practice and experience, vol. 26, iss. 3, pp. 800-820, 2014. doi:10.1002/cpe.3063

The whole computer hardware industry embraced multi-core. The extreme optimisation of sequential algorithms is then no longer sufficient to squeeze the real machine power, which can be only exploited via thread-level parallelism. Decision tree algorithms exhibit natural concurrency that makes them suitable to be parallelised. This paper presents an in-depth study of the parallelisation of an implementation of the C4.5 algorithm for multi-core architectures. We characterise elapsed time lower bounds for the forms of parallelisations adopted, and achieve close to optimal performances. Our implementation is based on the FastFlow parallel programming environment and it requires minimal changes to the original sequential code.

@article{yadtff:ccpe:13,
abstract = {The whole computer hardware industry embraced multi-core. The extreme optimisation of sequential algorithms is then no longer sufficient to squeeze the real machine power, which can be only exploited via thread-level parallelism. Decision tree algorithms exhibit natural concurrency that makes them suitable to be parallelised. This paper presents an in-depth study of the parallelisation of an implementation of the C4.5 algorithm for multi-core architectures. We characterise elapsed time lower bounds for the forms of parallelisations adopted, and achieve close to optimal performances. Our implementation is based on the FastFlow parallel programming environment and it requires minimal changes to the original sequential code.},
author = {Marco Aldinucci and Salvatore Ruggieri and Massimo Torquati},
date-modified = {2015-09-27 12:17:52 +0000},
doi = {10.1002/cpe.3063},
journal = {Concurrency and Computation: Practice and Experience},
keywords = {fastflow, paraphrase},
number = {3},
pages = {800-820},
title = {Decision Tree Building on Multi-Core using FastFlow},
volume = {26},
year = {2014},
bdsk-url-2 = {https://doi.org/10.1002/cpe.3063}
}

• M. Aldinucci, C. Calcagno, M. Coppo, F. Damiani, M. Drocco, E. Sciacca, S. Spinella, M. Torquati, and A. Troina, “On designing multicore-aware simulators for systems biology endowed with on-line statistics,” Biomed research international, 2014. doi:10.1155/2014/207041

The paper arguments are on enabling methodologies for the design of a fully parallel, online, interactive tool aiming to support the bioinformatics scientists .In particular, the features of these methodologies, supported by the FastFlow parallel programming framework, are shown on a simulation tool to perform the modeling, the tuning, and the sensitivity analysis of stochastic biological models. A stochastic simulation needs thousands of independent simulation trajectories turning into big data that should be analysed by statistic and data mining tools. In the considered approach the two stages are pipelined in such a way that the simulation stage streams out the partial results of all simulation trajectories to the analysis stage that immediately produces a partial result. The simulation-analysis workflow is validated for performance and effectiveness of the online analysis in capturing biological systems behavior on a multicore platform and representative proof-of-concept biological systems. The exploited methodologies include pattern-based parallel programming and data streaming that provide key features to the software designers such as performance portability and efficient in-memory (big) data management and movement. Two paradigmatic classes of biological systems exhibiting multistable and oscillatory behavior are used as a testbed.

@article{cwcsim:ff:multicore:biomed:14,
abstract = {The paper arguments are on enabling methodologies for the design of a fully parallel, online, interactive tool aiming to support the bioinformatics scientists .In particular, the features of these methodologies, supported by the FastFlow parallel programming framework, are shown on a simulation tool to perform the modeling, the tuning, and the sensitivity analysis of stochastic biological models. A stochastic simulation needs thousands of independent simulation trajectories turning into big data that should be analysed by statistic and data mining tools. In the considered approach the two stages are pipelined in such a way that the simulation stage streams out the partial results of all simulation trajectories to the analysis stage that immediately produces a partial result. The simulation-analysis workflow is validated for performance and effectiveness of the online analysis in capturing biological systems behavior on a multicore platform and representative proof-of-concept biological systems. The exploited methodologies include pattern-based parallel programming and data streaming that provide key features to the software designers such as performance portability and efficient in-memory (big) data management and movement. Two paradigmatic classes of biological systems exhibiting multistable and oscillatory behavior are used as a testbed.},
author = {Marco Aldinucci and Cristina Calcagno and Mario Coppo and Ferruccio Damiani and Maurizio Drocco and Eva Sciacca and Salvatore Spinella and Massimo Torquati and Angelo Troina},
date-modified = {2015-09-27 12:17:05 +0000},
doi = {10.1155/2014/207041},
journal = {BioMed Research International},
keywords = {fastflow,bioinformatics, paraphrase, biobits},
title = {On designing multicore-aware simulators for systems biology endowed with on-line statistics},
year = {2014},
bdsk-url-2 = {https://doi.org/10.1155/2014/207041}
}

• M. Aldinucci, M. Drocco, G. Peretti Pezzi, C. Misale, F. Tordini, and M. Torquati, “Exercising high-level parallel programming on streams: a systems biology use case,” in Proc. of 34th ieee intl. conference on distributed computing systems workshops (icdcsw), Madrid, Spain, 2014. doi:10.1109/ICDCSW.2014.38

The stochastic modelling of biological systems, cou- pled with Monte Carlo simulation of models, is an increasingly popular technique in Bioinformatics. The simulation-analysis workflow may result into a computationally expensive task reducing the interactivity required in the model tuning. In this work, we advocate high-level software design as a vehicle for building efficient and portable parallel simulators for a variety of platforms, ranging from multi-core platforms to GPGPUs to cloud. In particular, the Calculus of Wrapped Compartments (CWC) parallel simulator for systems biology equipped with on- line mining of results, which is designed according to the FastFlow pattern-based approach, is discussed as a running example. In this work, the CWC simulator is used as a paradigmatic example of a complex C++ application where the quality of results is correlated with both computation and I/O bounds, and where high-quality results might turn into big data. The FastFlow parallel programming framework, which advocates C++ pattern- based parallel programming makes it possible to develop portable parallel code without relinquish neither run-time efficiency nor performance tuning opportunities. Performance and effectiveness of the approach are validated on a variety of platforms, inter-alia cache-coherent multi-cores, cluster of multi-core (Ethernet and Infiniband) and the Amazon Elastic Compute Cloud.

@inproceedings{cwc:gpu:dcperf:14,
abstract = {The stochastic modelling of biological systems, cou- pled with Monte Carlo simulation of models, is an increasingly popular technique in Bioinformatics. The simulation-analysis workflow may result into a computationally expensive task reducing the interactivity required in the model tuning. In this work, we advocate high-level software design as a vehicle for building efficient and portable parallel simulators for a variety of platforms, ranging from multi-core platforms to GPGPUs to cloud. In particular, the Calculus of Wrapped Compartments (CWC) parallel simulator for systems biology equipped with on- line mining of results, which is designed according to the FastFlow pattern-based approach, is discussed as a running example. In this work, the CWC simulator is used as a paradigmatic example of a complex C++ application where the quality of results is correlated with both computation and I/O bounds, and where high-quality results might turn into big data. The FastFlow parallel programming framework, which advocates C++ pattern- based parallel programming makes it possible to develop portable parallel code without relinquish neither run-time efficiency nor performance tuning opportunities. Performance and effectiveness of the approach are validated on a variety of platforms, inter-alia cache-coherent multi-cores, cluster of multi-core (Ethernet and Infiniband) and the Amazon Elastic Compute Cloud.},
author = {Marco Aldinucci and Maurizio Drocco and Guilherme {Peretti Pezzi} and Claudia Misale and Fabio Tordini and Massimo Torquati},
booktitle = {Proc. of 34th IEEE Intl. Conference on Distributed Computing Systems Workshops (ICDCSW)},
date-modified = {2021-04-24 23:23:10 +0200},
doi = {10.1109/ICDCSW.2014.38},
keywords = {fastflow, bioinformatics, paraphrase, impact},
publisher = {IEEE},
title = {Exercising high-level parallel programming on streams: a systems biology use case},
url = {https://iris.unito.it/retrieve/handle/2318/154516/26657/2014_dcperf_cwc_gpu.pdf},
year = {2014},
bdsk-url-1 = {https://iris.unito.it/retrieve/handle/2318/154516/26657/2014_dcperf_cwc_gpu.pdf},
bdsk-url-2 = {https://doi.org/10.1109/ICDCSW.2014.38}
}

• M. Aldinucci, G. Peretti Pezzi, M. Drocco, F. Tordini, P. Kilpatrick, and M. Torquati, “Parallel video denoising on heterogeneous platforms,” in Proc. of intl. workshop on high-level programming for heterogeneous and hierarchical parallel systems (hlpgpu), 2014.

In this paper, a highly-effective parallel filter for video denoising is presented. The filter is designed using a skeletal approach, and has been implemented by way of the FastFlow parallel programming library. As a result of its high-level design, it is possible to run the filter seamlessly on a multi-core machine, on GPGPU(s), or on both. The design and the implementation of the filter are discussed, and an experimental evaluation is presented. Various mappings of the filtering stages are comparatively discussed.

@inproceedings{ff:video:hlpgpu:14,
abstract = {In this paper, a highly-effective parallel filter for video denoising is presented. The filter is designed using a skeletal approach, and has been implemented by way of the FastFlow parallel programming library. As a result of its high-level design, it is possible to run the filter seamlessly on a multi-core machine, on GPGPU(s), or on both. The design and the implementation of the filter are discussed, and an experimental evaluation is presented. Various mappings of the filtering stages are comparatively discussed.},
author = {Marco Aldinucci and Guilherme {Peretti Pezzi} and Maurizio Drocco and Fabio Tordini and Peter Kilpatrick and Massimo Torquati},
booktitle = {Proc. of Intl. Workshop on High-level Programming for Heterogeneous and Hierarchical Parallel Systems (HLPGPU)},
date-modified = {2015-09-27 12:42:02 +0000},
keywords = {fastflow, paraphrase, impact},
title = {Parallel video denoising on heterogeneous platforms},
year = {2014},
}

• M. Drocco, M. Aldinucci, and M. Torquati, “A dynamic memory allocator for heterogeneous platforms,” in Advanced computer architecture and compilation for high-performance and embedded systems (acaces) – poster abstracts, Fiuggi, Italy, 2014.

Modern computers are built upon heterogeneous multi-core/many cores architectures (e.g. GPGPU connected to multi-core CPU). Achieving peak performance on these architectures is hard and may require a substantial programming effort. High-level programming patterns, coupled with efficient low-level runtime supports, have been proposed to relieve the programmer from worrying about low-level details such as synchronisation of racing processes as well as those fine tunings needed to improve the overall performance. Among them are (parallel) dynamic memory allocation and effective exploitation of the memory hierarchy. The memory allocator is often a bottleneck that severely limits program scalability, robustness and portability on parallel systems. In this work we introduce a novel memory allocator, based on the FastFlow’s allocator and the recently proposed CUDA Unified Memory, which aims to efficiently integrate host and device memories into a unique dynamic-allocable memory space, accessible transparently by both host and device code.

@inproceedings{ff:acaces:14,
abstract = {Modern computers are built upon heterogeneous multi-core/many cores architectures (e.g. GPGPU connected to multi-core CPU). Achieving peak performance on these architectures is hard and may require a substantial programming effort. High-level programming patterns, coupled with efficient low-level runtime supports, have been proposed to relieve the programmer from worrying about low-level details such as synchronisation of racing processes as well as those fine tunings needed to improve the overall performance. Among them are (parallel) dynamic memory allocation and effective exploitation of the memory hierarchy. The memory allocator is often a bottleneck that severely limits program scalability, robustness and portability on parallel systems.
In this work we introduce a novel memory allocator, based on the FastFlow's allocator and the recently proposed CUDA Unified Memory, which aims to efficiently integrate host and device memories into a unique dynamic-allocable memory space, accessible transparently by both host and device code.},
author = {Maurizio Drocco and Marco Aldinucci and Massimo Torquati},
booktitle = {Advanced Computer Architecture and Compilation for High-Performance and Embedded Systems (ACACES) -- Poster Abstracts},
date-modified = {2016-08-20 17:29:47 +0000},
keywords = {fastflow, nvidia},
publisher = {HiPEAC},
title = {A Dynamic Memory Allocator for heterogeneous platforms},
year = {2014},
}

• C. Misale, G. Ferrero, M. Torquati, and M. Aldinucci, “Sequence alignment tools: one parallel pattern to rule them all?,” Biomed research international, 2014. doi:10.1155/2014/539410

In this paper we advocate high-level programming methodology for Next Generation Sequencers (NGS) alignment tools for both productivity and absolute performance. We analyse the problem of parallel alignment and review the parallelisation strategies of the most popular alignment tools, which can all be abstracted to a single parallel paradigm. We compare these tools against their porting onto the FastFlow pattern-based programming framework, which provides programmers with high-level parallel patterns. By using a high-level approach, programmers are liberated from all complex aspects of parallel programming, such as synchronisation protocols and task scheduling, gaining more possibility for seamless performance tuning. In this work we show some use case in which, by using a high-level approach for parallelising NGS tools, it is possible to obtain comparable or even better absolute performance for all used datasets.

@article{bowtie-bwa:ff:multicore:biomed:14,
abstract = {In this paper we advocate high-level programming methodology for Next Generation Sequencers (NGS) alignment tools for both productivity and absolute performance. We analyse the problem of parallel alignment and review the parallelisation strategies of the most popular alignment tools, which can all be abstracted to a single parallel paradigm. We compare these tools against their porting onto the FastFlow pattern-based programming framework, which provides programmers with high-level parallel patterns. By using a high-level approach, programmers are liberated from all complex aspects of parallel programming, such as synchronisation protocols and task scheduling, gaining more possibility for seamless performance tuning. In this work we show some use case in which, by using a high-level approach for parallelising NGS tools, it is possible to obtain comparable or even better absolute performance for all used datasets.
},
author = {Claudia Misale and Giulio Ferrero and Massimo Torquati and Marco Aldinucci},
date-modified = {2015-09-27 12:16:28 +0000},
doi = {10.1155/2014/539410},
journal = {BioMed Research International},
keywords = {fastflow,bioinformatics, paraphrase, repara},
title = {Sequence alignment tools: one parallel pattern to rule them all?},
year = {2014},
bdsk-url-2 = {http://dx.doi.org/10.1155/2014/539410}
}

### 2013

• M. Aldinucci, F. Tordini, M. Drocco, M. Torquati, and M. Coppo, “Parallel stochastic simulators in system biology: the evolution of the species,” in Proc. of 21st euromicro intl. conference on parallel distributed and network-based processing (pdp), Belfast, Nothern Ireland, U.K., 2013. doi:10.1109/PDP.2013.66

The stochastic simulation of biological systems is an increasingly popular technique in Bioinformatics. It is often an enlightening technique, especially for multi-stable systems which dynamics can be hardly captured with ordinary differential equations. To be effective, stochastic simulations should be supported by powerful statistical analysis tools. The simulation-analysis workflow may however result in being computationally expensive, thus compromising the interactivity required in model tuning. In this work we advocate the high-level design of simulators for stochastic systems as a vehicle for building efficient and portable parallel simulators. In particular, the Calculus of Wrapped Components (CWC) simulator, which is designed according to the FastFlow’s pattern-based approach, is presented and discussed in this work. FastFlow has been extended to support also clusters of multi-cores with minimal coding effort, assessing the portability of the approach.

@inproceedings{ff_cwc_distr:pdp:13,
abstract = {The stochastic simulation of biological systems is an increasingly popular technique in Bioinformatics. It is often an enlightening technique, especially for multi-stable systems which dynamics can be hardly captured with ordinary differential equations. To be effective, stochastic simulations should be supported by powerful statistical analysis tools. The simulation-analysis workflow may however result in being computationally expensive, thus compromising the interactivity required in model tuning. In this work we advocate the high-level design of simulators for stochastic systems as a vehicle for building efficient and portable parallel simulators. In particular, the Calculus of Wrapped Components (CWC) simulator, which is designed according to the FastFlow's pattern-based approach, is presented and discussed in this work. FastFlow has been extended to support also clusters of multi-cores with minimal coding effort, assessing the portability of the approach.},
address = {Belfast, Nothern Ireland, U.K.},
author = {Marco Aldinucci and Fabio Tordini and Maurizio Drocco and Massimo Torquati and Mario Coppo},
booktitle = {Proc. of 21st Euromicro Intl. Conference on Parallel Distributed and network-based Processing (PDP)},
date-modified = {2017-12-12 13:53:10 +0000},
doi = {10.1109/PDP.2013.66},
keywords = {fastflow, bioinformatics},
month = feb,
publisher = {IEEE},
title = {Parallel stochastic simulators in system biology: the evolution of the species},
year = {2013},
bdsk-url-2 = {http://dx.doi.org/10.1109/PDP.2013.66}
}

• C. Misale, M. Aldinucci, and M. Torquati, “Memory affinity in multi-threading: the bowtie2 case study,” in Advanced computer architecture and compilation for high-performance and embedded systems (acaces) – poster abstracts, Fiuggi, Italy, 2013.

@inproceedings{ff:acaces:13,
abstract = {The diffusion of the Next Generation Sequencing (NGS) has increased
the amount of data obtainable by genomic experiments. From a DNA sample a NGS run is able to produce millions of short sequences (called reads), which should be mapped into a reference genome. In this paper, we analyse the performance of Bowtie2, a fast and popular DNA mapping tool. Bowtie2 exhibits a multithreading implementation on top of pthreads, spin-locks and SSE2 SIMD extension.
From parallel computing viewpoint, is a paradigmatic example of a software requiring to address three
fundamental problems in shared-memory programming for cache-coherent multi-core platforms: synchronisation efficiency at very fine grain (due to short reads), load-balancing (due to long reads), and efficient usage of memory subsystem (due to SSE2 memory pressure).
We compare the original implementation against an alternative implementation on top of the
FastFlow pattern-based programming framework. The proposed design exploits the high-level farm pattern of FastFlow, which is implemented top of nonblocking multi-threading and lock-less (CAS-free) queues, and provides the programmer with high-level mechanism to tune task scheduling to achieve both load-balancing and memory affinity. The proposed design, despite the high-level design, is always faster and more scalable with respect to the original one.
The design of both original and alternative version will be presented along with their experimental evaluation on real-world data sets.},
author = {Claudia Misale and Marco Aldinucci and Massimo Torquati},
booktitle = {Advanced Computer Architecture and Compilation for High-Performance and Embedded Systems (ACACES) -- Poster Abstracts},
date-modified = {2015-03-21 15:12:59 +0000},
isbn = {9789038221908},
keywords = {fastflow},
publisher = {HiPEAC},
title = {Memory affinity in multi-threading: the Bowtie2 case study},
url = {https://iris.unito.it/retrieve/handle/2318/143005/23874/2013_ACACES_ex-abstract.pdf},
year = {2013},
bdsk-url-1 = {https://iris.unito.it/retrieve/handle/2318/143005/23874/2013_ACACES_ex-abstract.pdf}
}

• M. Aldinucci, M. Danelutto, P. Kilpatrick, C. Montangero, and L. Semini, “Managing adaptivity in parallel systems,” in Formal methods for components and objects: intl. symposium, fmco 2011, torino, italy, october 3-5, 2011, revised invited lectures, B. Beckert, F. Damiani, F. S. de Boer, and M. M. Bonsangue, Eds., Springer, 2013, vol. 7542, pp. 199-217. doi:10.1007/978-3-642-35887-6_11

The management of non-functional features (performance, security, power management, etc.) is traditionally a difficult, error prone task for programmers of parallel applications. To take care of these non-functional features, autonomic managers running policies represented as rules using sensors and actuators to monitor and transform a running parallel application may be used. We discuss an approach aimed at providing formal tool support to the integration of independently developed autonomic managers taking care of different non-functional concerns within the same parallel application. Our approach builds on the Behavioural Skeleton experience (autonomic management of non-functional features in structured parallel applications) and on previous results on conflict detection and resolution in rule-based systems.

@incollection{adaptivity:fmco:11,
abstract = {The management of non-functional features (performance, security, power management, etc.) is traditionally a difficult, error prone task for programmers of parallel applications. To take care of these non-functional features, autonomic managers running policies represented as rules using sensors and actuators to monitor and transform a running parallel application may be used. We discuss an approach aimed at providing formal tool support to the integration of independently developed autonomic managers taking care of different non-functional concerns within the same parallel application. Our approach builds on the Behavioural Skeleton experience (autonomic management of non-functional features in structured parallel applications) and on previous results on conflict detection and resolution in rule-based systems.},
author = {Marco Aldinucci and Marco Danelutto and Peter Kilpatrick and Carlo Montangero and Laura Semini},
booktitle = {Formal Methods for Components and Objects: Intl. Symposium, FMCO 2011, Torino, Italy, October 3-5, 2011, Revised Invited Lectures},
date-modified = {2021-04-24 23:22:33 +0200},
doi = {10.1007/978-3-642-35887-6_11},
editor = {Bernhard Beckert and Ferruccio Damiani and Frank S. de Boer and Marcello M. Bonsangue},
isbn = {978-3-642-35886-9},
keywords = {paraphrase},
pages = {199-217},
publisher = {Springer},
series = {LNCS},
title = {Managing Adaptivity in Parallel Systems},
volume = {7542},
year = {2013},
bdsk-url-2 = {http://dx.doi.org/10.1007/978-3-642-35887-6_11}
}

• M. Aldinucci, S. Campa, P. Kilpatrick, and M. Torquati, “Structured data access annotations for massively parallel computations,” in Euro-par 2012 workshops, proc. of the paraphrase workshop on parallel processing, 2013, pp. 381-390. doi:10.1007/978-3-642-36949-0_42

We describe an approach aimed at addressing the issue of joint exploitation of control (stream) and data parallelism in a skele-ton based parallel programming environment, based on annotations and refactoring. Annotations drive efficient implementation of a parallel com-putation. Refactoring is used to transform the associated skeleton tree into a more efficient, functionally equivalent skeleton tree. In most cases,cost models are used to drive the refactoring process. We show howsample use case applications/kernels may be optimized and discuss pre-liminary experiments with FastFlow assessing the theoretical results.

@inproceedings{annotation:para:12,
abstract = {We describe an approach aimed at addressing the issue of joint exploitation of control (stream) and data parallelism in a skele-ton based parallel programming environment, based on annotations and refactoring. Annotations drive efficient implementation of a parallel com-putation. Refactoring is used to transform the associated skeleton tree into a more efficient, functionally equivalent skeleton tree. In most cases,cost models are used to drive the refactoring process. We show howsample use case applications/kernels may be optimized and discuss pre-liminary experiments with FastFlow assessing the theoretical results.},
author = {Marco Aldinucci and Sonia Campa and Peter Kilpatrick and Massimo Torquati},
booktitle = {Euro-Par 2012 Workshops, Proc. of the ParaPhrase Workshop on Parallel Processing},
date-modified = {2015-09-27 12:49:52 +0000},
doi = {10.1007/978-3-642-36949-0_42},
keywords = {fastflow, paraphrase},
pages = {381-390},
publisher = {Springer},
series = {LNCS},
title = {Structured Data Access Annotations for Massively Parallel Computations},
volume = {7640},
year = {2013},
bdsk-url-2 = {https://doi.org/10.1007/978-3-642-36949-0_42}
}

• M. Aldinucci, S. Campa, M. Danelutto, P. Kilpatrick, and M. Torquati, “Targeting distributed systems in fastflow,” in Euro-par 2012 workshops, proc. of the coregrid workshop on grids, clouds and p2p computing, 2013, pp. 47-56. doi:10.1007/978-3-642-36949-0_7

FastFlow is a structured parallel programming framework targeting shared memory multi-core architectures. In this paper we introduce a FastFlow extension aimed at supporting a network of multi-core workstation as well. The extension supports the execution of FastFlow programs by coordinating – in a structured way – the fine grain parallel activities running on a single workstation. We discuss the design and the implementation of this extension presenting preliminary experimental results validating it on state-of-the-art networked multi-core nodes.

@inproceedings{ff:distr:cgs:12,
abstract = {FastFlow is a structured parallel programming framework targeting shared memory multi-core architectures. In this paper we introduce a FastFlow extension aimed at supporting a network of multi-core workstation as well. The extension supports the execution of FastFlow programs by coordinating -- in a structured way -- the fine grain parallel activities running on a single workstation. We discuss the design and the implementation of this extension presenting preliminary experimental results validating it on state-of-the-art networked multi-core nodes.},
author = {Marco Aldinucci and Sonia Campa and Marco Danelutto and Peter Kilpatrick and Massimo Torquati},
booktitle = {Euro-Par 2012 Workshops, Proc. of the CoreGrid Workshop on Grids, Clouds and P2P Computing},
date-modified = {2015-09-27 12:47:54 +0000},
doi = {10.1007/978-3-642-36949-0_7},
keywords = {fastflow, paraphrase},
pages = {47-56},
publisher = {Springer},
series = {LNCS},
title = {Targeting Distributed Systems in FastFlow},
volume = {7640},
year = {2013},
bdsk-url-2 = {http://dx.doi.org/10.1007/978-3-642-36949-0_7}
}

• K. Hammond, M. Aldinucci, C. Brown, F. Cesarini, M. Danelutto, H. González-Vélez, P. Kilpatrick, R. Keller, M. Rossbory, and G. Shainer, “The paraphrase project: parallel patterns for adaptive heterogeneous multicore systems,” in Formal methods for components and objects: intl. symposium, fmco 2011, torino, italy, october 3-5, 2011, revised invited lectures, B. Beckert, F. Damiani, F. S. de Boer, and M. M. Bonsangue, Eds., Springer, 2013, vol. 7542, pp. 218-236. doi:10.1007/978-3-642-35887-6_12

This paper describes the ParaPhrase project, a new 3-year targeted research project funded under EU Framework 7 Objective 3.4 (Computer Systems), starting in October 2011. ParaPhrase aims to follow a new approach to introducing parallelism using advanced refactoring techniques coupled with high-level parallel design patterns. The refactoring approach will use these design patterns to restructure programs defined as networks of software components into other forms that are more suited to parallel execution. The programmer will be aided by high-level cost information that will be integrated into the refactoring tools. The implementation of these patterns will then use a well-understood algorithmic skeleton approach to achieve good parallelism. A key ParaPhrase design goal is that parallel components are intended to match heterogeneous architectures, defined in terms of CPU/GPU combinations, for example. In order to achieve this, the ParaPhrase approach will map components at link time to the available hardware, and will then re-map them during program execution, taking account of multiple applications, changes in hardware resource availability, the desire to reduce communication costs etc. In this way, we aim to develop a new approach to programming that will be able to produce software that can adapt to dynamic changes in the system environment. Moreover, by using a strong component basis for parallelism, we can achieve potentially significant gains in terms of reducing sharing at a high level of abstraction, and so in reducing or even eliminating the costs that are usually associated with cache management, locking, and synchronisation.

@incollection{paraphrase:fmco:11,
abstract = {This paper describes the ParaPhrase project, a new 3-year targeted research project funded under EU Framework 7 Objective 3.4 (Computer Systems), starting in October 2011. ParaPhrase aims to follow a new approach to introducing parallelism using advanced refactoring techniques coupled with high-level parallel design patterns. The refactoring approach will use these design patterns to restructure programs defined as networks of software components into other forms that are more suited to parallel execution. The programmer will be aided by high-level cost information that will be integrated into the refactoring tools. The implementation of these patterns will then use a well-understood algorithmic skeleton approach to achieve good parallelism. A key ParaPhrase design goal is that parallel components are intended to match heterogeneous architectures, defined in terms of CPU/GPU combinations, for example. In order to achieve this, the ParaPhrase approach will map components at link time to the
available hardware, and will then re-map them during program execution, taking account of multiple applications, changes in hardware resource availability, the desire to reduce communication costs etc. In this way, we aim to develop a new approach to programming that will be able to produce software that can adapt to dynamic changes in the system environment. Moreover, by using a strong component basis for parallelism, we can achieve potentially significant gains in terms of reducing sharing at a high level of abstraction, and so in reducing or even eliminating the costs that are usually associated with cache management, locking, and synchronisation.},
author = {Kevin Hammond and Marco Aldinucci and Chris Brown and Francesco Cesarini and Marco Danelutto and Horacio Gonz\'alez-V\'elez and Peter Kilpatrick and Rainer Keller and Michael Rossbory and Gilad Shainer},
booktitle = {Formal Methods for Components and Objects: Intl. Symposium, FMCO 2011, Torino, Italy, October 3-5, 2011, Revised Invited Lectures},
date-modified = {2013-11-24 00:33:27 +0000},
doi = {10.1007/978-3-642-35887-6_12},
editor = {Bernhard Beckert and Ferruccio Damiani and Frank S. de Boer and Marcello M. Bonsangue},
isbn = {978-3-642-35886-9},
keywords = {paraphrase},
pages = {218-236},
publisher = {Springer},
series = {LNCS},
title = {The ParaPhrase Project: Parallel Patterns for Adaptive Heterogeneous Multicore Systems},
volume = {7542},
year = {2013},
bdsk-url-1 = {http://dx.doi.org/10.1007/978-3-642-35887-6_12},
}

• M. Aldinucci, S. Campa, F. Tordini, M. Torquati, and P. Kilpatrick, “An abstract annotation model for skeletons,” in Formal methods for components and objects: intl. symposium, fmco 2011, torino, italy, october 3-5, 2011, revised invited lectures, B. Beckert, F. Damiani, F. S. de Boer, and M. M. Bonsangue, Eds., Springer, 2013, vol. 7542, pp. 257-276. doi:10.1007/978-3-642-35887-6_14

Multi-core and many-core platforms are becoming increasingly heterogeneous and asymmetric. This significantly increases the porting and tuning effort required for parallel codes, which in turn often leads to a growing gap between peak machine power and actual application performance. In this work a first step toward the automated optimization of high level skeleton-based parallel code is discussed. The paper presents an abstract annotation model for skeleton programs aimed at formally describing suitable mapping of parallel activities on a high-level platform representation. The derived mapping and scheduling strategies are used to generate optimized run-time code.

@incollection{toolchain:fmco:11,
abstract = {Multi-core and many-core platforms are becoming increasingly heterogeneous and asymmetric. This significantly increases the porting and tuning effort required for parallel codes, which in turn often leads to a growing gap between peak machine power and actual application performance. In this work a first step toward the automated optimization of high level skeleton-based parallel code is discussed. The paper presents an abstract annotation model for skeleton programs aimed at formally describing suitable mapping of parallel activities on a high-level platform representation. The derived mapping and scheduling strategies are used to generate optimized run-time code.},
author = {Marco Aldinucci and Sonia Campa and Fabio Tordini and Massimo Torquati and Peter Kilpatrick},
booktitle = {Formal Methods for Components and Objects: Intl. Symposium, FMCO 2011, Torino, Italy, October 3-5, 2011, Revised Invited Lectures},
date-modified = {2013-11-24 00:33:41 +0000},
doi = {10.1007/978-3-642-35887-6_14},
editor = {Bernhard Beckert and Ferruccio Damiani and Frank S. de Boer and Marcello M. Bonsangue},
isbn = {978-3-642-35886-9},
keywords = {fastflow, paraphrase},
pages = {257-276},
publisher = {Springer},
series = {LNCS},
title = {An abstract annotation model for skeletons},
volume = {7542},
year = {2013},
bdsk-url-2 = {http://dx.doi.org/10.1007/978-3-642-35887-6_14}
}

### 2012

• M. Aldinucci, C. Spampinato, M. Drocco, M. Torquati, and S. Palazzo, “A parallel edge preserving algorithm for salt and pepper image denoising,” in Proc. of 2nd intl. conference on image processing theory tools and applications (ipta), Istambul, Turkey, 2012, pp. 97-102. doi:10.1109/IPTA.2012.6469567

In this paper a two-phase filter for removing “salt and pepper” noise is proposed. In the first phase, an adaptive median filter is used to identify the set of the noisy pixels; in the second phase, these pixels are restored according to a regularization method, which contains a data-fidelity term reflecting the impulse noise characteristics. The algorithm, which exhibits good performance both in denoising and in restoration, can be easily and effectively parallelized to exploit the full power of multi-core CPUs and GPGPUs; the proposed implementation based on the FastFlow library achieves both close-to-ideal speedup and very good wall-clock execution figures.

@inproceedings{denoiser:ff:ipta:12,
abstract = {In this paper a two-phase filter for removing salt and pepper'' noise is proposed. In the first phase, an adaptive median filter is used to identify the set of the noisy pixels; in the second phase, these pixels are restored according to a regularization method, which contains a data-fidelity term reflecting the impulse noise characteristics. The algorithm, which exhibits good performance both in denoising and in restoration, can be easily and effectively parallelized to exploit the full power of multi-core CPUs and GPGPUs; the proposed implementation based on the FastFlow library achieves both close-to-ideal speedup and very good wall-clock execution figures.},
author = {Marco Aldinucci and Concetto Spampinato and Maurizio Drocco and Massimo Torquati and Simone Palazzo},
booktitle = {Proc. of 2nd Intl. Conference on Image Processing Theory Tools and Applications (IPTA)},
date-modified = {2015-09-27 12:53:53 +0000},
doi = {10.1109/IPTA.2012.6469567},
editor = {K. Djemal and M. Deriche and W. Puech and Osman N. Ucan},
isbn = {978-1-4673-2582-0},
keywords = {fastflow, impact},
month = oct,
pages = {97-102},
publisher = {IEEE},
title = {A Parallel Edge Preserving Algorithm for Salt and Pepper Image Denoising},
year = {2012},
bdsk-url-2 = {http://dx.doi.org/10.1109/IPTA.2012.6469567}
}

• M. Aldinucci, M. Danelutto, P. Kilpatrick, M. Meneghin, and M. Torquati, “An efficient unbounded lock-free queue for multi-core systems,” in Proc. of 18th intl. euro-par 2012 parallel processing, Rhodes Island, Greece, 2012, pp. 662-673. doi:10.1007/978-3-642-32820-6_65

The use of efficient synchronization mechanisms is crucial for implementing fine grained parallel programs on modern shared cache multi-core architectures. In this paper we study this problem by considering Single-Producer/Single-Consumer (SPSC) coordination using unbounded queues. A novel unbounded SPSC algorithm capable of reducing the row synchronization latency and speeding up Producer-Consumer coordination is presented. The algorithm has been extensively tested on a shared-cache multi-core platform and a sketch proof of correctness is presented. The queues proposed have been used as basic building blocks to implement the FastFlow parallel framework, which has been demonstrated to offer very good performance for fine-grain parallel applications.

@inproceedings{ff:spsc:europar:12,
abstract = {The use of efficient synchronization mechanisms is crucial for implementing fine grained parallel programs on modern shared cache multi-core architectures. In this paper we study this problem by considering Single-Producer/Single-Consumer (SPSC) coordination using unbounded queues. A novel unbounded SPSC algorithm capable of reducing the row synchronization latency and speeding up Producer-Consumer coordination is presented. The algorithm has been extensively tested on a shared-cache multi-core platform and a sketch proof of correctness is presented. The queues proposed have been used as basic building blocks to implement the FastFlow parallel framework, which has been demonstrated to offer very good performance for fine-grain parallel applications.},
author = {Marco Aldinucci and Marco Danelutto and Peter Kilpatrick and Massimiliano Meneghin and Massimo Torquati},
booktitle = {Proc. of 18th Intl. Euro-Par 2012 Parallel Processing},
date-modified = {2015-09-27 12:55:20 +0000},
doi = {10.1007/978-3-642-32820-6_65},
keywords = {fastflow, paraphrase},
month = aug,
pages = {662-673},
publisher = {Springer},
series = {LNCS},
title = {An Efficient Unbounded Lock-Free Queue for Multi-core Systems},
volume = {7484},
year = {2012},
bdsk-url-2 = {http://dx.doi.org/10.1007/978-3-642-32820-6_65}
}

• M. Aldinucci, M. Danelutto, P. Kilpatrick, and M. Torquati, “Targeting heterogeneous architectures via macro data flow,” Parallel processing letters, vol. 22, iss. 2, 2012. doi:10.1142/S0129626412400063

We propose a data flow based run time system as an efficient tool for supporting execution of parallel code on heterogeneous architectures hosting both multicore CPUs and GPUs. We discuss how the proposed run time system may be the target of both structured parallel applications developed using algorithmic skeletons/parallel design patterns and also more “domain specific” programming models. Experimental results demonstrating the feasibility of the approach are presented.

@article{mdf:hplgpu:ppl:12,
abstract = {We propose a data flow based run time system as an efficient tool for supporting execution of parallel code on heterogeneous architectures hosting both multicore CPUs and GPUs. We discuss how the proposed run time system may be the target of both structured parallel applications developed using algorithmic skeletons/parallel design patterns and also more domain specific'' programming models. Experimental results demonstrating the feasibility of the approach are presented.},
annote = {Extended version of Intl. Workshop on High-level Programming for Heterogeneous and Hierarchical Parallel Systems (HLPGPU)},
author = {Marco Aldinucci and Marco Danelutto and Peter Kilpatrick and Massimo Torquati},
date-modified = {2015-09-27 12:55:11 +0000},
doi = {10.1142/S0129626412400063},
issn = {0129-6264},
journal = {Parallel Processing Letters},
keywords = {fastflow, paraphrase},
month = jun,
number = {2},
title = {Targeting heterogeneous architectures via macro data flow},
volume = {22},
year = {2012},
bdsk-url-2 = {http://dx.doi.org/10.1142/S0129626412400063}
}

• M. Aldinucci, M. Danelutto, L. Anardu, M. Torquati, and P. Kilpatrick, “Parallel patterns + macro data flow for multi-core programming,” in Proc. of intl. euromicro pdp 2012: parallel distributed and network-based processing, Garching, Germany, 2012, pp. 27-36. doi:10.1109/PDP.2012.44

Data flow techniques have been around since the early ’70s when they were used in compilers for sequential languages. Shortly after their introduction they were also considered as a possible model for parallel computing, although the impact here was limited. Recently, however, data flow has been identified as a candidate for efficient implementation of various programming models on multi-core architectures. In most cases, however, the burden of determining data flow “macro” instructions is left to the programmer, while the compiler/run time system manages only the efficient scheduling of these instructions. We discuss a structured parallel programming approach supporting automatic compilation of programs to macro data flow and we show experimental results demonstrating the feasibility of the approach and the efficiency of the resulting “object” code on different classes of state-of-the-art multi-core architectures. The experimental results use different base mechanisms to implement the macro data flow run time support, from plain pthreads with condition variables to more modern and effective lock- and fence-free parallel frameworks. Experimental results comparing efficiency of the proposed approach with those achieved using other, more classical, parallel frameworks are also presented.

@inproceedings{dataflow:pdp:12,
abstract = {Data flow techniques have been around since the early '70s when they were used in compilers for sequential languages. Shortly after their introduction they were also considered as a possible model for parallel computing, although the impact here was limited. Recently, however, data flow has been identified as a candidate for efficient implementation of various programming models on multi-core architectures. In most cases, however, the burden of determining data flow macro'' instructions is left to the programmer, while the compiler/run time system manages only the efficient scheduling of these instructions. We discuss a structured parallel programming approach supporting automatic compilation of programs to macro data flow and we show experimental results demonstrating the feasibility of the approach and the efficiency of the resulting object'' code on different classes of state-of-the-art multi-core architectures. The experimental results use different base mechanisms to implement the
macro data flow run time support, from plain pthreads with condition variables to more modern and effective lock- and fence-free parallel frameworks. Experimental results comparing efficiency of the proposed approach with those achieved using other, more classical, parallel frameworks are also presented.},
author = {Marco Aldinucci and Marco Danelutto and Lorenzo Anardu and Massimo Torquati and Peter Kilpatrick},
booktitle = {Proc. of Intl. Euromicro PDP 2012: Parallel Distributed and network-based Processing},
date-modified = {2013-11-24 00:35:34 +0000},
doi = {10.1109/PDP.2012.44},
keywords = {fastflow},
month = feb,
pages = {27-36},
publisher = {IEEE},
title = {Parallel patterns + Macro Data Flow for multi-core programming},
year = {2012},
bdsk-url-2 = {http://dx.doi.org/10.1109/PDP.2012.44}
}

• M. Aldinucci, M. Coppo, F. Damiani, M. Drocco, E. Sciacca, S. Spinella, M. Torquati, and A. Troina, “On parallelizing on-line statistics for stochastic biological simulations,” in Proc. of euro-par workshops: 2nd workshop on high performance bioinformatics and biomedicine (hibb), Bordeaux, France, 2012, pp. 3-12. doi:10.1007/978-3-642-29740-3_2

This work concerns a general technique to enrich parallel version of stochastic simulators for biological systems with tools for on-line statistical analysis of the results. In particular, within the FastFlow parallel programming framework, we describe the methodology and the implementation of a parallel Monte Carlo simulation infrastructure extended with user-defined on-line data filtering and mining functions. The simulator and the on-line analysis were validated on large multi-core platforms and representative proof-of-concept biological systems.

@inproceedings{cwcsim:onlinestats:ff:hibb:11,
abstract = {This work concerns a general technique to enrich parallel version of stochastic simulators for biological systems with tools for on-line statistical analysis of the results. In particular, within the FastFlow parallel programming framework, we describe the methodology and the implementation of a parallel Monte Carlo simulation infrastructure extended with user-defined on-line data filtering and mining functions. The simulator and the on-line analysis were validated on large multi-core platforms and representative proof-of-concept biological systems.},
author = {Marco Aldinucci and Mario Coppo and Ferruccio Damiani and Maurizio Drocco and Eva Sciacca and Salvatore Spinella and Massimo Torquati and Angelo Troina},
booktitle = {Proc. of Euro-Par Workshops: 2nd Workshop on High Performance Bioinformatics and Biomedicine (HiBB)},
date-modified = {2017-12-12 14:47:15 +0000},
doi = {10.1007/978-3-642-29740-3_2},
editor = {Michael Alexander and Pasqua D'Ambra and Adam Belloum and George Bosilca and Mario Cannataro and Marco Danelutto and Beniamino Di Martino and Michael Gerndt and Emmanuel Jeannot and Raymond Namyst and Jean Roman and Stephen L. Scott and Jesper Larsson Tr{\"a}ff and Geoffroy Vall{\'e}e and Josef Weidendorfer},
keywords = {bioinformatics, fastflow},
pages = {3-12},
publisher = {Springer},
series = {LNCS},
title = {On Parallelizing On-Line Statistics for Stochastic Biological Simulations},
volume = {7156},
year = {2012},
bdsk-url-2 = {http://dx.doi.org/10.1007/978-3-642-29740-3_2}
}

• F. Tordini, M. Aldinucci, and M. Torquati, “High-level lock-less programming for multicore,” in Advanced computer architecture and compilation for high-performance and embedded systems (acaces) – poster abstracts, Fiuggi, Italy, 2012.

Modern computers are built upon multi-core architectures. Achieving peak performance on these architectures is hard and may require a substantial programming effort. The synchronisation of many processes racing to access a common resource (the shared memory) has been a fundamental problem on parallel computing for years, and many solutions have been proposed to address this issue. Non-blocking synchronisation and transactional primitives have been envisioned as a way to reduce memory wall problem. Despite sometimes effective (and exhibiting a great momentum in the research community), they are only one facet of the problem, as their exploitation still requires non-trivial programming skills. With non-blocking philosophy in mind, we propose high-level programming patterns that will relieve the programmer from worrying about low-level details such as synchronisation of racing processes as well as those fine tunings needed to improve the overall performance, like proper (distributed) dynamic memory allocation and effective exploitation of the memory hierarchy.

@inproceedings{ff:acaces:12,
abstract = {Modern computers are built upon multi-core architectures. Achieving peak performance on these architectures is hard and may require a substantial programming effort. The synchronisation of many processes racing to access a common resource (the shared memory) has been a fundamental problem on parallel computing for years, and many solutions have been proposed to address this issue. Non-blocking synchronisation and transactional primitives have been envisioned as a way to reduce memory wall problem. Despite sometimes effective (and exhibiting a great momentum in the research community), they are only one facet of the problem, as their exploitation still requires non-trivial programming skills.
With non-blocking philosophy in mind, we propose high-level programming patterns that will relieve the programmer from worrying about low-level details such as synchronisation of racing processes as well as those fine tunings needed to improve the overall performance, like proper (distributed) dynamic memory allocation and effective exploitation of the memory hierarchy.},
author = {Fabio Tordini and Marco Aldinucci and Massimo Torquati},
booktitle = {Advanced Computer Architecture and Compilation for High-Performance and Embedded Systems (ACACES) -- Poster Abstracts},
date-modified = {2013-11-24 00:36:10 +0000},
isbn = {9789038219875},
keywords = {fastflow},
publisher = {HiPEAC},
title = {High-level lock-less programming for multicore},
year = {2012},
}

• T. Weigold, M. Aldinucci, M. Danelutto, and V. Getov, “Process-driven biometric identification by means of autonomic grid components,” Int. j. of autonomous and adaptive communications systems, vol. 5, iss. 3, pp. 274-291, 2012. doi:10.1504/IJAACS.2012.047659

Today’s business applications are increasingly process driven, meaning that the main application logic is executed by a dedicate process engine. In addition, component-oriented software development has been attracting attention for building complex distributed applications. In this paper we present the experiences gained from building a process-driven biometric identification application that makes use of Grid infrastructures via the Grid Component Model (GCM). GCM, besides guaranteeing access to Grid resources, supports autonomic management of notable parallel composite components. This feature is exploited within our biometric identification application to ensure real time identification of fingerprints. Therefore, we briefly introduce the GCM framework and the process engine used, and we describe the implementation of the application by means of autonomic GCM components. Finally, we summarize the results, experiences, and lessons learned focusing on the integration of autonomic GCM components and the process-driven approach.

@article{ibm:ijaacs:12,
abstract = {Today's business applications are increasingly process driven, meaning that the main application logic is executed by a dedicate process engine. In addition, component-oriented software development has been attracting attention for building complex distributed applications. In this paper we present the experiences gained from building a process-driven biometric identification application that makes use of Grid infrastructures via the Grid Component Model (GCM). GCM, besides guaranteeing access to Grid resources, supports autonomic management of notable parallel composite components. This feature is exploited within our biometric identification application to ensure real time identification of fingerprints. Therefore, we briefly introduce the GCM framework and the process engine used, and we describe the implementation of the application by means of autonomic GCM components. Finally, we summarize the results, experiences, and lessons learned focusing on the integration of autonomic GCM components
and the process-driven approach.},
author = {Thomas Weigold and Marco Aldinucci and Marco Danelutto and Vladimir Getov},
date-modified = {2013-06-17 14:14:36 +0000},
doi = {10.1504/IJAACS.2012.047659},
issn = {1754-8632},
journal = {Int. J. of Autonomous and Adaptive Communications Systems},
number = {3},
pages = {274-291},
publisher = {Inderscience Enterprises Ltd.},
title = {Process-Driven Biometric Identification by means of Autonomic Grid Components},
volume = {5},
year = {2012},
bdsk-url-1 = {http://www.inderscience.com/info/inarticletoc.php?jcode=ijaacs&year=2012&vol=5&issue=3},
bdsk-url-3 = {http://dx.doi.org/10.1504/IJAACS.2012.047659}
}

### 2011

• M. Aldinucci, M. Danelutto, P. Kilpatrick, and V. Xhagjika, “Libero: a framework for autonomic management of multiple non-functional concerns,” in Euro-par 2010 workshops, proc. of the coregrid workshop on grids, clouds and p2p computing, Ischia, Italy, 2011, pp. 237-245. doi:10.1007/978-3-642-21878-1_30

We describe a lightweight prototype framework (LIBERO) designed for experimentation with behavioural skeletons-components implementing a well-known parallelism exploitation pattern and a rule-based autonomic manager taking care of some non-functional feature related to pattern computation. LIBERO supports multiple autonomic managers within the same behavioural skeleton, each taking care of a different non-functional concern. We introduce LIBERO – built on plain Java and JBoss – and discuss how multiple managers may be coordinated to achieve a common goal using a two-phase coordination protocol developed in earlier work. We present experimental results that demonstrate how the prototype may be used to investigate autonomic management of multiple, independent concerns.

@inproceedings{libero:cgsymph:10,
abstract = {We describe a lightweight prototype framework (LIBERO) designed for experimentation with behavioural skeletons-components implementing a well-known parallelism exploitation pattern and a rule-based autonomic manager taking care of some non-functional feature related to pattern computation. LIBERO supports multiple autonomic managers within the same behavioural skeleton, each taking care of a different non-functional concern. We introduce LIBERO -- built on plain Java and JBoss -- and discuss how multiple managers may be coordinated to achieve a common goal using a two-phase coordination protocol developed in earlier work. We present experimental results that demonstrate how the prototype may be used to investigate autonomic management of multiple, independent concerns.},
author = {Marco Aldinucci and Marco Danelutto and Peter Kilpatrick and Vamir Xhagjika},
booktitle = {Euro-Par 2010 Workshops, Proc. of the CoreGrid Workshop on Grids, Clouds and P2P Computing},
date-modified = {2012-12-27 14:26:15 +0000},
doi = {10.1007/978-3-642-21878-1_30},
editor = {M. R. Guarracino and F. Vivien and J. L. Tr\"aff and M. Cannataro and M. Danelutto and A. Hast and F. Perla and A. Kn\"upfer and B. Di Martino and M. Alexander},
month = sep,
pages = {237-245},
publisher = {Springer},
series = {LNCS},
title = {LIBERO: a framework for autonomic management of multiple non-functional concerns},
volume = {6586},
year = {2011},
bdsk-url-2 = {http://dx.doi.org/10.1007/978-3-642-21878-1_30}
}

• M. Aldinucci, M. Danelutto, P. Kilpatrick, M. Meneghin, and M. Torquati, “Accelerating code on multi-cores with fastflow,” in Proc. of 17th intl. euro-par 2011 parallel processing, Bordeaux, France, 2011, pp. 170-181. doi:10.1007/978-3-642-23397-5_17

FastFlow is a programming framework specifically targeting cache-coherent shared-memory multicores. It is implemented as a stack of C++ template libraries built on top of lock-free (and memory fence free) synchronization mechanisms. Its philosophy is to combine programmability with performance. In this paper a new FastFlow programming methodology aimed at supporting parallelization of existing sequential code via offloading onto a dynamically created software accelerator is presented. The new methodology has been validated using a set of simple micro-benchmarks and some real applications.

@inproceedings{ff:acc:europar:11,
abstract = {FastFlow is a programming framework specifically targeting cache-coherent shared-memory multicores. It is implemented as a stack of C++ template libraries built on top of lock-free (and memory fence free) synchronization mechanisms. Its philosophy is to combine programmability with performance. In this paper a new FastFlow programming methodology aimed at supporting parallelization of existing sequential code via offloading onto a dynamically created software accelerator is presented. The new methodology has been validated using a set of simple micro-benchmarks and some real applications.},
author = {Marco Aldinucci and Marco Danelutto and Peter Kilpatrick and Massimiliano Meneghin and Massimo Torquati},
booktitle = {Proc. of 17th Intl. Euro-Par 2011 Parallel Processing},
date-modified = {2013-12-12 00:46:59 +0000},
doi = {10.1007/978-3-642-23397-5_17},
editor = {E. Jeannot and R. Namyst and J. Roman},
keywords = {fastflow},
month = aug,
pages = {170-181},
publisher = {Springer},
series = {LNCS},
title = {Accelerating code on multi-cores with FastFlow},
volume = {6853},
year = {2011},
bdsk-url-2 = {http://dx.doi.org/10.1007/978-3-642-23397-5_17}
}

• M. Aldinucci, A. Bracciali, P. Liò, A. Sorathiya, and M. Torquati, “StochKit-FF: efficient systems biology on multicore architectures,” in Euro-par 2010 workshops, proc. of the 1st workshop on high performance bioinformatics and biomedicine (hibb), Ischia, Italy, 2011, pp. 167-175. doi:10.1007/978-3-642-21878-1_21

The stochastic modelling of biological systems is an informative, and in some cases, very adequate technique, which may however result in being more expensive than other modelling approaches, such as differential equations. We present StochKit-FF, a parallel version of StochKit, a reference toolkit for stochastic simulations. StochKit-FF is based on the FastFlow programming toolkit for multicores and exploits the novel concept of selective memory. We experiment StochKit-FF on a model of HIV infection dynamics, with the aim of extracting information from efficiently run experiments, here in terms of average and variance and, on a longer term, of more structured data.

@inproceedings{stochkit-ff:hibb:10,
abstract = {The stochastic modelling of biological systems is an informative, and in some cases, very adequate technique, which may however result in being more expensive than other modelling approaches, such as differential equations. We present StochKit-FF, a parallel version of StochKit, a reference toolkit for stochastic simulations. StochKit-FF is based on the FastFlow programming toolkit for multicores and exploits the novel concept of selective memory. We experiment StochKit-FF on a model of HIV infection dynamics, with the aim of extracting information from efficiently run experiments, here in terms of average and variance and, on a longer term, of more structured data.},
author = {Marco Aldinucci and Andrea Bracciali and Pietro Li\o and Anil Sorathiya and Massimo Torquati},
booktitle = {Euro-Par 2010 Workshops, Proc. of the 1st Workshop on High Performance Bioinformatics and Biomedicine (HiBB)},
date-modified = {2013-11-24 00:36:38 +0000},
doi = {10.1007/978-3-642-21878-1_21},
editor = {M. R. Guarracino and F. Vivien and J. L. Tr\"aff and M. Cannataro and M. Danelutto and A. Hast and F. Perla and A. Kn\"upfer and B. Di Martino and M. Alexander},
keywords = {bioinformatics},
month = aug,
pages = {167-175},
publisher = {Springer},
series = {{LNCS}},
title = {{StochKit-FF}: Efficient Systems Biology on Multicore Architectures},
volume = {6586},
year = {2011},
bdsk-url-2 = {http://dx.doi.org/10.1007/978-3-642-21878-1_21}
}

• M. Aldinucci, M. Coppo, F. Damiani, M. Drocco, M. Torquati, and A. Troina, “On designing multicore-aware simulators for biological systems,” in Proc. of 19th euromicro intl. conference on parallel distributed and network-based processing (pdp), Ayia Napa, Cyprus, 2011, pp. 318-325. doi:10.1109/PDP.2011.81

The stochastic simulation of biological systems is an increasingly popular technique in bioinformatics. It often is an enlightening technique, which may however result in being computational expensive. We discuss the main opportunities to speed it up on multi-core platforms, which pose new challenges for parallelisation techniques. These opportunities are developed in two general families of solutions involving both the single simulation and a bulk of independent simulations (either replicas of derived from parameter sweep). Proposed solutions are tested on the parallelisation of the CWC simulator (Calculus of Wrapped Compartments) that is carried out according to proposed solutions by way of the FastFlow programming framework making possible fast development and efficient execution on multi-cores.

@inproceedings{ff:cwc:pdp:11,
abstract = {The stochastic simulation of biological systems is an increasingly popular technique in bioinformatics. It often is an enlightening technique, which may however result in being computational expensive. We discuss the main opportunities to speed it up on multi-core platforms, which pose new challenges for parallelisation techniques. These opportunities are developed in two general families of solutions involving both the single simulation and a bulk of independent simulations (either replicas of derived from parameter sweep). Proposed solutions are tested on the parallelisation of the CWC simulator (Calculus of Wrapped Compartments) that is carried out according to proposed solutions by way of the FastFlow programming framework making possible fast development and efficient execution on multi-cores.},
author = {Marco Aldinucci and Mario Coppo and Ferruccio Damiani and Maurizio Drocco and Massimo Torquati and Angelo Troina},
booktitle = {Proc. of 19th Euromicro Intl. Conference on Parallel Distributed and network-based Processing (PDP)},
date-modified = {2017-12-12 13:51:21 +0000},
doi = {10.1109/PDP.2011.81},
editor = {Yiannis Cotronis and Marco Danelutto and George Angelos Papadopoulos},
keywords = {fastflow},
month = feb,
pages = {318-325},
publisher = {IEEE},
title = {On Designing Multicore-Aware Simulators for Biological Systems},
year = {2011},
bdsk-url-1 = {http://arxiv.org/pdf/1010.2438v2},
bdsk-url-3 = {http://dx.doi.org/10.1109/PDP.2011.81}
}

### 2010

• M. Aldinucci, S. Ruggieri, and M. Torquati, “Porting decision tree algorithms to multicore using FastFlow,” in Proc. of european conference in machine learning and knowledge discovery in databases (ecml pkdd), Barcelona, Spain, 2010, pp. 7-23. doi:10.1007/978-3-642-15880-3_7

The whole computer hardware industry embraced multicores. For these machines, the extreme optimisation of sequential algorithms is no longer sufficient to squeeze the real machine power, which can be only exploited via thread-level parallelism. Decision tree algorithms exhibit natural concurrency that makes them suitable to be parallelised. This paper presents an approach for easy-yet-efficient porting of an implementation of the C4.5 algorithm on multicores. The parallel porting requires minimal changes to the original sequential code, and it is able to exploit up to 7X speedup on an Intel dual-quad core machine.

@inproceedings{fastflow_c45:emclpkdd,
abstract = {The whole computer hardware industry embraced multicores. For these machines, the extreme optimisation of sequential algorithms is no longer sufficient to squeeze the real machine power, which can be only exploited via thread-level parallelism. Decision tree algorithms exhibit natural concurrency that makes them suitable to be parallelised. This paper presents an approach for easy-yet-efficient porting of an implementation of the C4.5 algorithm on multicores. The parallel porting requires minimal changes to the original sequential code, and it is able to exploit up to 7X speedup on an Intel dual-quad core machine.},
author = {Marco Aldinucci and Salvatore Ruggieri and Massimo Torquati},
booktitle = {Proc. of European Conference in Machine Learning and Knowledge Discovery in Databases (ECML PKDD)},
date-modified = {2013-11-24 00:38:07 +0000},
doi = {10.1007/978-3-642-15880-3_7},
editor = {Jos{\'e} L. Balc{\'a}zar and Francesco Bonchi and Aristides Gionis and Mich{\e}le Sebag},
keywords = {fastflow},
month = sep,
pages = {7-23},
publisher = {Springer},
series = {LNCS},
title = {Porting Decision Tree Algorithms to Multicore using {FastFlow}},
volume = {6321},
year = {2010},
bdsk-url-2 = {http://dx.doi.org/10.1007/978-3-642-15880-3_7}
}

• M. Aldinucci, M. Danelutto, and P. Kilpatrick, “Autonomic management of multiple non-functional concerns in behavioural skeletons,” in Grids, p2p and services computing, F. Desprez, V. Getov, T. Priol, and R. Yahyapour, Eds., Springer, 2010, pp. 89-103. doi:10.1007/978-1-4419-6794-7_8

We introduce and address the problem of concurrent autonomic management of different non-functional concerns in parallel applications build as a hierarchical composition of behavioural skeletons. We first define the problems arising when multiple concerns are dealt with by independent managers, then we propose a methodology supporting coordinated management, and finally we discuss how autonomic management of multiple concerns may be implemented in a typical use case. Being based on the behavioural skeleton concept proposed in the CoreGRID GCM, it is anticipated that the methodology will be readily integrated into the current reference implementation of GCM based on Java ProActive and running on top of major grid middleware systems.

@incollection{multiple-nf-concern:cgsymph:09:book,
abstract = {We introduce and address the problem of concurrent autonomic management of different non-functional concerns in parallel applications build as a hierarchical composition of behavioural skeletons. We first define the problems arising when multiple concerns are dealt with by independent managers, then we propose a methodology supporting coordinated management, and finally we discuss how autonomic management of multiple concerns may be implemented in a typical use case. Being based on the behavioural skeleton concept proposed in the CoreGRID GCM, it is anticipated that the methodology will be readily integrated into the current reference implementation of GCM based on Java ProActive and running on top of major grid middleware systems.},
annote = {ISBN: 978-1-4419-6793-0(Proc. of the CoreGRID Symposium 2009)},
author = {Marco Aldinucci and Marco Danelutto and Peter Kilpatrick},
booktitle = {Grids, P2P and Services Computing},
date-modified = {2012-02-25 00:39:47 +0000},
doi = {10.1007/978-1-4419-6794-7_8},
editor = {Fr\'ed\'eric Desprez and Vladimir Getov and Thierry Priol and Ramin Yahyapour},
month = aug,
pages = {89-103},
publisher = {Springer},
series = {CoreGRID},
title = {Autonomic Management of Multiple Non-Functional Concerns in Behavioural Skeletons},
year = {2010},
bdsk-url-2 = {http://dx.doi.org/10.1007/978-1-4419-6794-7_8}
}

• M. Aldinucci, A. Bracciali, and P. Liò, “Formal synthetic immunology,” Ercim news, vol. 82, pp. 40-41, 2010.

The human immune system fights pathogens using an articulated set of strategies whose function is to maintain in health the organism. A large effort to formally model such a complex system using a computational approach is currently underway, with the goal of developing a discipline for engineering “synthetic” immune responses. This requires the integration of a range of analysis techniques developed for formally reasoning about the behaviour of complex dynamical systems. Furthermore, a novel class of software tools has to be developed, capable of efficiently analysing these systems on widely accessible computing platforms, such as commodity multi-core architectures..

@article{stochkitff:ercimnews:10,
abstract = {The human immune system fights pathogens using an articulated set of strategies whose function is to maintain in health the organism. A large effort to formally model such a complex system using a computational approach is currently underway, with the goal of developing a discipline for engineering "synthetic" immune responses. This requires the integration of a range of analysis techniques developed for formally reasoning about the behaviour of complex dynamical systems. Furthermore, a novel class of software tools has to be developed, capable of efficiently analysing these systems on widely accessible computing platforms, such as commodity multi-core architectures..},
author = {Marco Aldinucci and Andrea Bracciali and Pietro Li\o},
date-modified = {2013-11-24 00:38:19 +0000},
issn = {0926-4981},
journal = {ERCIM News},
keywords = {bioinformatics, fastflow},
month = jul,
pages = {40-41},
title = {Formal Synthetic Immunology},
url = {http://ercim-news.ercim.eu/images/stories/EN82/EN82-web.pdf},
volume = {82},
year = {2010},
bdsk-url-1 = {http://ercim-news.ercim.eu/images/stories/EN82/EN82-web.pdf}
}

• M. Aldinucci, M. Meneghin, and M. Torquati, “Efficient Smith-Waterman on multi-core with fastflow,” in Proc. of intl. euromicro pdp 2010: parallel distributed and network-based processing, Pisa, Italy, 2010, pp. 195-199. doi:10.1109/PDP.2010.93

Shared memory multiprocessors have returned to popularity thanks to rapid spreading of commodity multi-core architectures. However, little attention has been paid to supporting effective streaming applications on these architectures. In this paper we describe FastFlow, a low-level programming framework based on lock-free queues explicitly designed to support high-level languages for streaming applications. We compare FastFlow with state-of-the-art programming frameworks such as Cilk, OpenMP, and Intel TBB. We experimentally demonstrate that FastFlow is always more efficient than them on a given real world application: the speedup of FastFlow over other solutions may be substantial for fine grain tasks, for example +35% over OpenMP, +226% over Cilk, +96% over TBB for the alignment of protein P01111 against UniProt DB using the Smith-Waterman algorithm.

@inproceedings{fastflow:pdp:10,
abstract = {Shared memory multiprocessors have returned to popularity thanks to rapid spreading of commodity multi-core architectures. However, little attention has been paid to supporting effective streaming applications on these architectures. In this paper we describe FastFlow, a low-level programming framework based on lock-free queues explicitly designed to support high-level languages for streaming applications. We compare FastFlow with state-of-the-art programming frameworks such as Cilk, OpenMP, and Intel TBB. We experimentally demonstrate that FastFlow is always more efficient than them on a given real world application: the speedup of FastFlow over other solutions may be substantial for fine grain tasks, for example +35% over OpenMP, +226% over Cilk, +96% over TBB for the alignment of protein P01111 against UniProt DB using the Smith-Waterman algorithm.},
author = {Marco Aldinucci and Massimiliano Meneghin and Massimo Torquati},
booktitle = {Proc. of Intl. Euromicro PDP 2010: Parallel Distributed and network-based Processing},
date-modified = {2013-11-24 00:38:51 +0000},
doi = {10.1109/PDP.2010.93},
editor = {Marco Danelutto and Tom Gross and Julien Bourgeois},
keywords = {fastflow},
month = feb,
pages = {195-199},
publisher = {IEEE},
title = {Efficient {Smith-Waterman} on multi-core with FastFlow},
year = {2010},
bdsk-url-2 = {http://dx.doi.org/10.1109/PDP.2010.93}
}

• M. Aldinucci, “Efficient parallel MonteCarlo with FastFlow,” in Hpc-europa2: science and supercomputing in europe, research highlights 2010, Cineca, 2010.

The stochastic simulation of natural systems is a very informative but happens be computationally expensive. We present StochKit-FF, an parallel version of StochKit, a reference toolkit for stochastic simulations that sustantially improves StochKit performances on multi-core platforms.

@incollection{ff:hpc-europa:10,
abstract = {The stochastic simulation of natural systems is a very informative but happens be computationally expensive. We present StochKit-FF, an parallel version of StochKit, a reference toolkit for stochastic simulations that sustantially improves StochKit performances on multi-core platforms.},
author = {Marco Aldinucci},
booktitle = {HPC-Europa2: Science and Supercomputing in Europe, research highlights 2010},
date-modified = {2013-11-24 00:40:04 +0000},
keywords = {bioinformatics, fastflow},
publisher = {Cineca},
title = {Efficient Parallel {MonteCarlo} with {FastFlow}},
year = {2010},
}

• T. Weigold, M. Aldinucci, M. Danelutto, and V. Getov, “Integrating autonomic grid components and process-driven business applications,” in Autonomic computing and communications systems third international icst conference, autonomics 2009, limassol, cyprus, september 9-11, 2009, revised selected papers, Limassol, Cyprus, 2010, pp. 98-113. doi:10.1007/978-3-642-11482-3_7

Today’s business applications are increasingly process driven, meaning that the main application logic is executed by a dedicate process engine. In addition, component-oriented software development has been attracting attention for building complex distributed applications. In this paper we present the experiences gained from building a process-driven biometric identification application which makes use of Grid infrastructures via the Grid Component Model (GCM). GCM, besides guaranteeing access to Grid resources, supports autonomic management of notable parallel composite components. This feature is exploited within our biometric identification application to ensure real time identification of fingerprints. Therefore, we briefly introduce the GCM framework and the process engine used, and we describe the implementation of the application using autonomic GCM components. Finally, we summarize the results, experiences, and lessons learned focusing on the integration of autonomic GCM components and the process-driven approach.

@inproceedings{ibm:autonomics:09,
abstract = {Today's business applications are increasingly process driven, meaning that the main application logic is executed by a dedicate process engine. In addition, component-oriented software development has been attracting attention for building complex distributed applications. In this paper we present the experiences gained from building a process-driven biometric identification application which makes use of Grid infrastructures via the Grid Component Model (GCM). GCM, besides guaranteeing access to Grid resources, supports autonomic management of notable parallel composite components. This feature is exploited within our biometric identification application to ensure real time identification of fingerprints. Therefore, we briefly introduce the GCM framework and the process engine used, and we describe the implementation of the application using autonomic GCM components. Finally, we summarize the results, experiences, and lessons learned focusing on the integration of autonomic GCM components and the process-driven approach.},
annote = {ISBN: 978-3-642-11481-6},
author = {Thomas Weigold and Marco Aldinucci and Marco Danelutto and Vladimir Getov},
booktitle = {Autonomic Computing and Communications Systems Third International ICST Conference, Autonomics 2009, Limassol, Cyprus, September 9-11, 2009, Revised Selected Papers},
date-modified = {2012-11-24 09:44:22 +0000},
doi = {10.1007/978-3-642-11482-3_7},
editor = {Athanasios V. Vasilakos and Roberto Beraldi and Roy Friedman and Marco Mamei},
issn = {1867-8211},
pages = {98-113},
publisher = {Springer},
series = {{Lecture Notes of the Institute for Computer Sciences, Social-Informatics and Telecommunications Engineering (LNICST)}},
title = {Integrating Autonomic Grid Components and Process-Driven Business Applications},
volume = {23},
year = {2010},
bdsk-url-1 = {http://dx.doi.org/10.1007/978-3-642-11482-3_7},
}

• M. Aldinucci, M. Danelutto, and P. Kilpatrick, “Skeletons for multi/many-core systems,” in Parallel computing: from multicores and gpu’s to petascale (proc. of PARCO 2009, lyon, france), Lyon, France, 2010, pp. 265-272. doi:10.3233/978-1-60750-530-3-265

We discuss how algorithmic skeletons (and structured parallel programming models in general) can be used to efficiently and seamlessly program multi-core as well as many-core systems. We introduce a new version of the muskel skeleton library that can be used to target multi/many-core systems and we present experimental results that demonstrate the feasibility of the approach. The experimental results presented also give an idea of the computational grains that can be exploited on current, state-of-the-art multi-core systems.

@inproceedings{multicoreske:parco:09,
abstract = {We discuss how algorithmic skeletons (and structured parallel programming models in general) can be used to efficiently and seamlessly program multi-core as well as many-core systems. We introduce a new version of the muskel skeleton library that can be used to target multi/many-core systems and we present experimental results that demonstrate the feasibility of the approach. The experimental results presented also give an idea of the computational grains that can be exploited on current, state-of-the-art multi-core systems.},
annote = {ISBN: 978-1-60750-529-7},
author = {Marco Aldinucci and Marco Danelutto and Peter Kilpatrick},
booktitle = {Parallel Computing: From Multicores and GPU's to Petascale (Proc. of {PARCO 2009}, Lyon, France)},
date-modified = {2012-11-24 09:43:35 +0000},
doi = {10.3233/978-1-60750-530-3-265},
editor = {Barbara Chapman and Fr{\'e}d{\'e}ric Desprez and Gerhard R. Joubert and Alain Lichnewsky and Frans Peters and Thierry Priol},
pages = {265-272},
publisher = {IOS press},
series = {Advances in Parallel Computing},
title = {Skeletons for multi/many-core systems},
volume = {19},
year = {2010},
bdsk-url-2 = {http://dx.doi.org/10.3233/978-1-60750-530-3-265}
}

• M. Aldinucci, M. Danelutto, M. Meneghin, M. Torquati, and P. Kilpatrick, “Efficient streaming applications on multi-core with fastflow: the biosequence alignment test-bed.” Elsevier, 2010, vol. 19, pp. 273-280. doi:10.3233/978-1-60750-530-3-273

Shared-memory multi-core architectures are becoming increasingly popular. While their parallelism and peak performance is ever increasing, their efficiency is often disappointing due to memory fence overheads. In this paper we present FastFlow, a programming methodology based on lock-free queues explicitly designed for programming streaming applications on multi-cores. The potential of FastFlow is evaluated on micro-benchmarks and on the Smith-Waterman sequence alignment application, which exhibits a substantial speedup against the state-of-the-art multi-threaded implementation (SWPS3 x86/SSE2).

@inbook{fastflow:parco:09,
abstract = {Shared-memory multi-core architectures are becoming increasingly popular. While their parallelism and peak performance is ever increasing, their efficiency is often disappointing due to memory fence overheads. In this paper we present FastFlow, a programming methodology based on lock-free queues explicitly designed for programming streaming applications on multi-cores. The potential of FastFlow is evaluated on micro-benchmarks and on the Smith-Waterman sequence alignment application, which exhibits a substantial speedup against the state-of-the-art multi-threaded implementation (SWPS3 x86/SSE2).},
author = {Aldinucci,M. and Danelutto,M. and Meneghin,M. and Torquati,M. and Kilpatrick,P.},
date-modified = {2019-03-25 23:17:15 +0100},
doi = {10.3233/978-1-60750-530-3-273},
keywords = {fastflow},
language = {English},
opteditor = {Barbara Chapman and Fr{\'e}d{\'e}ric Desprez and Gerhard R. Joubert and Alain Lichnewsky and Frans Peters and Thierry Priol},
pages = {273-280},
publisher = {Elsevier},
series = {Advances in Parallel Computing},
title = {Efficient streaming applications on multi-core with FastFlow: The biosequence alignment test-bed},
url = {https://iris.unito.it/retrieve/handle/2318/67254/690859/2009_fastflow_parco.pdf},
volume = {19},
year = {2010},
bdsk-url-1 = {https://iris.unito.it/retrieve/handle/2318/67254/690859/2009_fastflow_parco.pdf},
bdsk-url-2 = {https://doi.org/10.3233/978-1-60750-530-3-273}
}

### 2009

• M. Aldinucci, H. L. Bouziane, M. Danelutto, and C. Pérez, “STKM on SCA: a unified framework with components, workflows and algorithmic skeletons,” in Proc. of 15th intl. euro-par 2009 parallel processing, Delft, The Netherlands, 2009, pp. 678-690. doi:10.1007/978-3-642-03869-3

This paper investigates an implementation of STKM, a Spatio-Temporal sKeleton Model. STKM expands the Grid Component Model (GCM) with an innovative programmable approach that allows programmers to compose an application by combining component, workflow and skeleton concepts. The paper deals with a projection of the STKM model on top of SCA and it evaluates its implementation using Tuscany Java SCA. Experimental results show the need and the benefits of the high level of abstraction offered by STKM.

@inproceedings{stkm:europar:09,
abstract = {This paper investigates an implementation of STKM, a Spatio-Temporal sKeleton Model. STKM expands the Grid Component Model (GCM) with an innovative programmable approach that allows programmers to compose an application by combining component, workflow and skeleton concepts. The paper deals with a projection of the STKM model on top of SCA and it evaluates its implementation using Tuscany Java SCA. Experimental results show the need and the benefits of the high level of abstraction offered by STKM.},
author = {Marco Aldinucci and Hinde Lilia Bouziane and Marco Danelutto and Christian P{\'e}rez},
booktitle = {Proc. of 15th Intl. Euro-Par 2009 Parallel Processing},
date-modified = {2009-12-03 00:58:56 +0100},
doi = {10.1007/978-3-642-03869-3},
month = aug,
pages = {678-690},
publisher = {Springer},
series = {LNCS},
title = {{STKM} on {SCA}: a Unified Framework with Components, Workflows and Algorithmic Skeletons},
volume = {5704},
year = {2009},
bdsk-url-2 = {http://dx.doi.org/10.1007/978-3-642-03869-3}
}

• M. Aldinucci, M. Danelutto, and P. Kilpatrick, “Autonomic management of non-functional concerns in distributed and parallel application programming,” in Proc. of intl. parallel & distributed processing symposium (ipdps), Rome, Italy, 2009, pp. 1-12. doi:10.1109/IPDPS.2009.5161034

An approach to the management of non-functional concerns in massively parallel and/or distributed architectures that marries parallel programming patterns with autonomic computing is presented. The necessity and suitability of the adoption of autonomic techniques are evidenced. Issues arising in the implementation of autonomic managers taking care of multiple concerns and of coordination among hierarchies of such autonomic managers are discussed. Experimental results are presented that demonstrate the feasibility of the approach.

@inproceedings{beske:ipdps:09,
abstract = {An approach to the management of non-functional concerns in massively parallel and/or distributed architectures that marries parallel programming patterns with autonomic computing is presented. The necessity and suitability of the adoption of autonomic techniques are evidenced. Issues arising in the implementation of autonomic managers taking care of multiple concerns and of coordination among hierarchies of such autonomic managers are discussed. Experimental results are presented that demonstrate the feasibility of the approach.},
author = {Marco Aldinucci and Marco Danelutto and Peter Kilpatrick},
booktitle = {Proc. of Intl. Parallel \& Distributed Processing Symposium (IPDPS)},
date-modified = {2009-06-07 22:30:35 +0200},
doi = {10.1109/IPDPS.2009.5161034},
month = {may},
pages = {1-12},
publisher = {IEEE},
title = {Autonomic management of non-functional concerns in distributed and parallel application programming},
year = {2009},
bdsk-url-2 = {http://dx.doi.org/10.1109/IPDPS.2009.5161034}
}

• M. Aldinucci, M. Danelutto, and P. Kilpatrick, “Co-design of distributed systems using skeletons and autonomic management abstractions,” in Euro-par 2008 workshops – parallel processing, selected papers, Las Palmas, Spain, 2009, pp. 403-414. doi:10.1007/978-3-642-00955-6_46

We discuss how common problems arising with multi/many-core distributed architectures can be effectively handled through co-design of parallel/distributed programming abstractions and of autonomic management of non-functional concerns. In particular, we demonstrate how restricted parallel/distributed patterns (or skeletons) may be efficiently managed by rule-based autonomic managers. We discuss the basic principles underlying pattern+manager co-design, current implementations inspired by this approach and some results achieved with a proof-of-concept prototype.

@inproceedings{abstraction:europarworkshop:09,
abstract = {We discuss how common problems arising with multi/many-core distributed architectures can be effectively handled through co-design of parallel/distributed programming abstractions and of autonomic management of non-functional concerns. In particular, we demonstrate how restricted parallel/distributed patterns (or skeletons) may be efficiently managed by rule-based autonomic managers. We discuss the basic principles underlying pattern+manager co-design, current implementations inspired by this approach and some results achieved with a proof-of-concept prototype.},
author = {Marco Aldinucci and Marco Danelutto and Peter Kilpatrick},
booktitle = {Euro-Par 2008 Workshops - Parallel Processing, Selected Papers},
date-modified = {2009-06-26 16:12:56 +0200},
doi = {10.1007/978-3-642-00955-6_46},
editor = {E. C{\'e}sar and M. Alexander and A. Streit and J.L. Tr{\"a}ff and C. C{\'e}rin and A. Kn{\"u}pfer and D. Kranzlm{\"u}ller and S. Jha},
isbn = {978-3-642-00954-9},
month = apr,
pages = {403-414},
publisher = {Springer},
series = {LNCS},
title = {Co-design of distributed systems using skeletons and autonomic management abstractions},
volume = {5415},
year = {2009},
bdsk-url-2 = {http://dx.doi.org/10.1007/978-3-642-00955-6_46}
}

• M. Aldinucci, M. Danelutto, and P. Kilpatrick, “Towards hierarchical management of autonomic components: a case study,” in Proc. of intl. euromicro pdp 2009: parallel distributed and network-based processing, Weimar, Germany, 2009, pp. 3-10. doi:10.1109/PDP.2009.48

We address the issue of autonomic management in hierarchical component-based distributed systems. The long term aim is to provide a modeling framework for autonomic management in which QoS goals can be defined, plans for system adaptation described and proofs of achievement of goals by (sequences of) adaptations furnished. Here we present an early step on this path. We restrict our focus to skeleton-based systems in order to exploit their well-defined structure. The autonomic cycle is described using the Orc system orchestration language while the plans are presented as structural modifications together with associated costs and benefits. A case study is presented to illustrate the interaction of managers to maintain QoS goals for throughput under varying conditions of resource availability.

@inproceedings{beske:pdp:09,
abstract = {We address the issue of autonomic management in hierarchical component-based distributed systems. The long term aim is to provide a modeling framework for autonomic management in which QoS goals can be defined, plans for system adaptation described and proofs of achievement of goals by (sequences of) adaptations furnished. Here we present an early step on this path. We restrict our focus to skeleton-based systems in order to exploit their well-defined structure. The autonomic cycle is described using the Orc system orchestration language while the plans are presented as structural modifications together with associated costs and benefits. A case study is presented to illustrate the interaction of managers to maintain QoS goals for throughput under varying conditions of resource availability.},
author = {Marco Aldinucci and Marco Danelutto and Peter Kilpatrick},
booktitle = {Proc. of Intl. Euromicro PDP 2009: Parallel Distributed and network-based Processing},
date-modified = {2009-05-20 10:26:13 +0200},
doi = {10.1109/PDP.2009.48},
editor = {Didier El Baz and Tom Gross and Francois Spies},
month = feb,
pages = {3-10},
publisher = {IEEE},
title = {Towards hierarchical management of autonomic components: a case study},
year = {2009},
bdsk-url-2 = {http://dx.doi.org/10.1109/PDP.2009.48}
}

• M. Aldinucci, S. Campa, P. Dazzi, N. Tonellotto, and G. Zoppi, D.NFCF.05 – nfcf tuned prototype and final documentation, 2009.
[BibTeX]
@misc{gridcomp:D.NFCF.05,
author = {Marco Aldinucci and Sonia Campa and Patrizio Dazzi and Nicola Tonellotto and Giorgio Zoppi},
date-modified = {2009-01-25 23:42:02 +0100},
howpublished = {\url{ http://gridcomp.ercim.org/}},
month = jan,
title = {{D.NFCF.05} -- NFCF tuned prototype and final documentation},
year = {2009}
}

• M. Aldinucci, M. Danelutto, and P. Kilpatrick, “Semi-formal models to support program development: autonomic management within component based parallel and distributed programming,” in Formal methods for components and objects: 7th intl. symposium, fmco 2008, sophia-antipolis, france, october 20 – 24, 2008, revised lectures, 2009, pp. 204-225. doi:10.1007/978-3-642-04167-9

Functional and non-functional concerns require different programming effort, different techniques and different methodologies when attempting to program efficient parallel/distributed applications. In this work we present a “programmer oriented” methodology based on formal tools that permits reasoning about parallel/distributed program development and refinement. The proposed methodology is semi-formal in that it does not require the exploitation of highly formal tools and techniques, while providing a palatable and effective support to programmers developing parallel/distributed applications, in particular when handling non-functional concerns.

@inproceedings{semi-formal:fmco:09,
abstract = {Functional and non-functional concerns require different programming effort, different techniques and different methodologies when attempting to program efficient parallel/distributed applications. In this work we present a programmer oriented'' methodology based on formal tools that permits reasoning about parallel/distributed program development and refinement. The proposed methodology is semi-formal in that it does not require the exploitation of highly formal tools and techniques, while providing a palatable and effective support to programmers developing parallel/distributed applications, in particular when handling non-functional concerns.},
author = {Marco Aldinucci and Marco Danelutto and Peter Kilpatrick},
booktitle = {Formal Methods for Components and Objects: 7th Intl. Symposium, FMCO 2008, Sophia-Antipolis, France, October 20 - 24, 2008, Revised Lectures},
date-modified = {2009-08-30 17:11:01 +0200},
doi = {10.1007/978-3-642-04167-9},
editor = {Frank S. de Boer and Marcello M. Bonsangue and Eric Madelaine},
pages = {204-225},
publisher = {Springer},
series = {LNCS},
title = {Semi-formal models to support program development: autonomic management within component based parallel and distributed programming},
volume = {5751},
year = {2009},
bdsk-url-2 = {http://dx.doi.org/10.1007/978-3-642-04167-9}
}

### 2008

• M. Aldinucci, G. Antoniu, M. Danelutto, and M. Jan, “Fault-tolerant data sharing for high-level grid programming: a hierarchical storage architecture,” in Achievements in european research on grid systems, M. Bubak, S. Gorlatch, and T. Priol, Eds., Kraków, Poland: Springer, 2008, pp. 67-81. doi:10.1007/978-0-387-72812-4_6

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).

@incollection{assist:juxmem:IW_book:07,
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).},
author = {Marco Aldinucci and Gabriel Antoniu and Marco Danelutto and Mathieu Jan},
booktitle = {Achievements in European Research on Grid Systems},
date-modified = {2012-11-18 17:45:08 +0000},
doi = {10.1007/978-0-387-72812-4_6},
editor = {Marian Bubak and Sergei Gorlatch and Thierry Priol},
isbn = {978-0-387-72811-7},
month = nov,
pages = {67-81},
publisher = {Springer},
series = {CoreGRID},
title = {Fault-Tolerant Data Sharing for High-level Grid Programming: A Hierarchical Storage Architecture},
year = {2008},
bdsk-url-2 = {http://dx.doi.org/10.1007/978-0-387-72812-4_6}
}

• M. Aldinucci, M. Danelutto, H. L. Bouziane, and C. Pérez, “Towards software component assembly language enhanced with workflows and skeletons,” in Proc. of the acm sigplan component-based high performance computing (cbhpc), New York, NY, USA, 2008, pp. 1-11. doi:10.1145/1456190.1456194

We explore the possibilities offered by a programming model supporting components, workflows and skeletons. In particular we describe how Stcm (Spatio-Temporal Component Model), an already existing programming model supporting components and workflows, can be extended to also provide algorithmic skeleton concepts. Programmers are therefore enabled to assembly applications specifying both temporal and spatial relations among components and instantiating predefined skeleton composite components to implement all those application parts that can be easily modeled with the available skeletons. We discuss preliminary results as well as the benefits deriving from Stkm (Spatio-Temporal sKeleton Model) adoption in a couple of real applications.

@inproceedings{stkm:CBHPC:08,
abstract = {We explore the possibilities offered by a programming model supporting components, workflows and skeletons. In particular we describe how Stcm (Spatio-Temporal Component Model), an already existing programming model supporting components and workflows, can be extended to also provide algorithmic skeleton concepts. Programmers are therefore enabled to assembly applications specifying both temporal and spatial relations among components and instantiating predefined skeleton composite components to implement all those application parts that can be easily modeled with the available skeletons. We discuss preliminary results as well as the benefits deriving from Stkm (Spatio-Temporal sKeleton Model) adoption in a couple of real applications.},
address = {New York, NY, USA},
author = {Aldinucci, Marco and Danelutto, Marco and Bouziane, Hinde Lilia and P{\'e}rez, Christian},
booktitle = {Proc. of the ACM SIGPLAN Component-Based High Performance Computing (CBHPC)},
date-modified = {2008-11-17 18:33:20 +0100},
doi = {10.1145/1456190.1456194},
isbn = {978-1-60558-311-2},
location = {Karlsruhe, Germany},
month = oct,
pages = {1-11},
publisher = {ACM},
title = {Towards Software Component Assembly Language Enhanced with Workflows and Skeletons},
year = {2008},
bdsk-url-2 = {http://dx.doi.org/10.1145/1456190.1456194}
}

• M. Aldinucci and M. Danelutto, “Securing skeletal systems with limited performance penalty: the Muskel experience,” Journal of systems architecture, vol. 54, iss. 9, pp. 868-876, 2008. doi:10.1016/j.sysarc.2008.02.008

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.

@article{security:jsa:07,
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.},
author = {Marco Aldinucci and Marco Danelutto},
date-modified = {2014-08-24 22:18:21 +0000},
doi = {10.1016/j.sysarc.2008.02.008},
journal = {Journal of Systems Architecture},
month = sep,
number = {9},
pages = {868-876},
publisher = {Elsevier},
title = {Securing skeletal systems with limited performance penalty: the {Muskel} experience},
volume = {54},
year = {2008},
bdsk-url-2 = {http://dx.doi.org/10.1016/j.sysarc.2008.02.008}
}

• M. Aldinucci, S. Campa, M. Danelutto, P. Dazzi, P. Kilpatrick, D. Laforenza, and N. Tonellotto, “Behavioural skeletons for component autonomic management on grids,” in Making grids work, M. Danelutto, P. Frangopoulou, and V. Getov, Eds., Springer, 2008, pp. 3-16. doi:10.1007/978-0-387-78448-9_1

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.

@incollection{beske:cg_book:08,
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.},
author = {Marco Aldinucci and Sonia Campa and Marco Danelutto and Patrizio Dazzi and Peter Kilpatrick and Domenico Laforenza and Nicola Tonellotto},
booktitle = {Making Grids Work},
chapter = {Component Programming Models},
date-modified = {2008-11-17 20:07:48 +0100},
doi = {10.1007/978-0-387-78448-9_1},
isbn = {978-0-387-78447-2},
month = aug,
pages = {3-16},
publisher = {Springer},
series = {CoreGRID},
title = {Behavioural skeletons for component autonomic management on grids},
year = {2008},
bdsk-url-2 = {http://dx.doi.org/10.1007/978-0-387-78448-9_1}
}

• M. Aldinucci, M. Danelutto, G. Zoppi, and P. Kilpatrick, “Advances in autonomic components & services,” in From grids to service and pervasive computing (proc. of the coregrid symposium 2008), Las Palmas, Spain, 2008, pp. 3-18. doi:10.1007/978-0-387-09455-7_1

Hierarchical autonomic management of structured grid applications can be efficiently implemented using production rule engines. Rules of the form “precondition-to-action” can be used to model the behaviour of autonomic managers in such a way that the autonomic control and the application management strategy are kept separate. This simplifies the manager design as well as user customization of autonomic manager policies. We briefly introduce rule-based autonomic managers. Then we discuss an implementation of a GCM-like behavioural skeleton – a composite component modelling a standard parallelism exploitation pattern with its own autonomic controller – in SCA/Tuscany. The implementation uses the JBoss rules engine to provide an autonomic behavioural skeleton component and services to expose the component functionality to the standard service framework. Performance results are discussed and finally similarities and differences with respect to the ProActive-based reference GCM implementation are discussed briefly.

@inproceedings{sca:cgsymph:08,
abstract = {Hierarchical autonomic management of structured grid applications can be efficiently implemented using production rule engines. Rules of the form "precondition-to-action" can be used to model the behaviour of autonomic managers in such a way that the autonomic control and the application management strategy are kept separate. This simplifies the manager design as well as user customization of autonomic manager policies. We briefly introduce rule-based autonomic managers. Then we discuss an implementation of a GCM-like behavioural skeleton -- a composite component modelling a standard parallelism exploitation pattern with its own autonomic controller -- in SCA/Tuscany. The implementation uses the JBoss rules engine to provide an autonomic behavioural skeleton component and services to expose the component functionality to the standard service framework. Performance results are discussed and finally similarities and differences with respect to the ProActive-based reference GCM implementation are discussed briefly.},
author = {Marco Aldinucci and Marco Danelutto and Giorgio Zoppi and Peter Kilpatrick},
booktitle = {From Grids To Service and Pervasive Computing (Proc. of the CoreGRID Symposium 2008)},
date-modified = {2012-11-17 16:11:44 +0000},
doi = {10.1007/978-0-387-09455-7_1},
editor = {Thierry Priol and Marco Vanneschi},
isbn = {978-0-387-09454-0},
month = aug,
pages = {3-18},
publisher = {Springer},
series = {CoreGRID},
title = {Advances in Autonomic Components {\&} Services},
year = {2008},
bdsk-url-2 = {http://dx.doi.org/10.1007/978-0-387-09455-7_1}
}

• M. Aldinucci and E. Tuosto, “Towards a formal semantics for autonomic components,” in From grids to service and pervasive computing (proc. of the coregrid symposium 2008), Las Palmas, Spain, 2008, pp. 31-45. doi:10.1007/978-0-387-09455-7_3

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.

@inproceedings{sem:cgsymph:08,
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.},
author = {Marco Aldinucci and Emilio Tuosto},
booktitle = {From Grids To Service and Pervasive Computing (Proc. of the CoreGRID Symposium 2008)},
date-modified = {2010-02-13 19:32:53 +0100},
doi = {10.1007/978-0-387-09455-7_3},
editor = {Thierry Priol and Marco Vanneschi},
isbn = {978-0-387-09454-0},
month = aug,
pages = {31-45},
publisher = {Springer},
series = {CoreGRID},
title = {Towards a Formal Semantics for Autonomic Components},
year = {2008},
bdsk-url-2 = {http://dx.doi.org/10.1007/978-0-387-09455-7_3}
}

• M. Aldinucci, S. Campa, P. Dazzi, N. Tonellotto, and G. Zoppi, D.NFCF.03 – methodology to derive performance models for component and composite components, 2008.
[BibTeX]
@misc{gridcomp:D.NFCF.03,
author = {Marco Aldinucci and Sonia Campa and Patrizio Dazzi and Nicola Tonellotto and Giorgio Zoppi},
date-modified = {2008-09-19 15:54:19 +0200},
howpublished = {\url{ http://gridcomp.ercim.org/}},
month = jun,
title = {{D.NFCF.03} -- Methodology to derive performance models for component and composite components},
year = {2008}
}

• M. Aldinucci, S. Campa, P. Dazzi, N. Tonellotto, and G. Zoppi, D.NFCF.04 – NFCF prototype and early documentation, 2008.
[BibTeX]
@misc{gridcomp:D.NFCF.04,
author = {Marco Aldinucci and Sonia Campa and Patrizio Dazzi and Nicola Tonellotto and Giorgio Zoppi},
date-modified = {2009-01-25 23:50:44 +0100},
howpublished = {\url{ http://gridcomp.ercim.org/}},
month = jun,
title = {{D.NFCF.04} -- {NFCF} prototype and early documentation},
year = {2008}
}

• M. Aldinucci, Coregrid institute on programming modelBarcelona, Spain: , 2008.
@misc{ogf:cg:poster:08,
author = {Marco Aldinucci},
date-modified = {2014-06-21 15:28:48 +0000},
howpublished = {Open Grid Forum (OGF), CoreGRID Industrial Showcase},
month = jun,
note = {Poster},
title = {CoreGRID Institute on Programming Model},
year = {2008},
}

• M. Aldinucci, M. Danelutto, P. Kilpatrick, and P. Dazzi, “From Orc models to distributed grid Java code,” in Proc. of the integrated research in grid computing workshop, Hersonissos, Crete, Greece, 2008, pp. 2-13.

We present O2J, a Java library that allows implementation of Orc programs on distributed architectures including grids and clusters/networks of workstations. With minimal programming effort the grid programmer may implement Orc programs, as he/she is not required to write any low level code relating to distributed orchestration of the computation but only that required to implement Orc expressions. Using the prototype O2J implementation, grid application developers can reason about abstract grid orchestration code described in Orc. Once the required orchestration has been determined and its properties analysed, a grid application prototype can be simply, efficiently and quickly implemented by taking the Orc code, rewriting it into corresponding Java/O2J syntax and finally providing the functional code implementing the sites and processes involved. The proposed modus operandi brings a Model Driven Engineering approach to grid application development.

@inproceedings{orc:IW:08,
abstract = {We present O2J, a Java library that allows implementation of Orc programs on distributed architectures including grids and clusters/networks of workstations. With minimal programming effort the grid programmer may implement Orc programs, as he/she is not required to write any low level code relating to distributed orchestration of the computation but only that required to implement Orc expressions. Using the prototype O2J implementation, grid application developers can reason about abstract grid orchestration code described in Orc. Once the required orchestration has been determined and its properties analysed, a grid application prototype can be simply, efficiently and quickly implemented by taking the Orc code, rewriting it into corresponding Java/O2J syntax and finally providing the functional code implementing the sites and processes involved. The proposed modus operandi brings a Model Driven Engineering approach to grid application development.},
author = {Marco Aldinucci and Marco Danelutto and Peter Kilpatrick and Patrizio Dazzi},
booktitle = {Proc. of the Integrated Research in Grid Computing Workshop},
date-modified = {2012-11-18 18:07:06 +0000},
editor = {Sergei Gorlatch and Paraskevi Fragopoulou and Thierry Priol},
keywords = {Duplicate},
month = apr,
pages = {2-13},
series = {CoreGRID},
title = {From {Orc} Models to Distributed Grid {Java} code},
year = {2008},
}

• M. Aldinucci and A. Benoit, “Automatic mapping of ASSIST applications using process algebra,” Parallel processing letters, vol. 18, iss. 1, pp. 175-188, 2008. doi:10.1142/S0129626408003302

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.

@article{assist:pepa:ppl:08,
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.},
annote = {ISSN: 0129-6264},
author = {Marco Aldinucci and Anne Benoit},
date-modified = {2013-06-17 14:09:49 +0000},
doi = {10.1142/S0129626408003302},
issn = {0129-6264},
journal = {Parallel Processing Letters},
month = mar,
number = {1},
pages = {175-188},
title = {Automatic mapping of {ASSIST} applications using process algebra},
volume = {18},
year = {2008},
bdsk-url-2 = {http://dx.doi.org/10.1142/S0129626408003302}
}

• M. Aldinucci, S. Campa, M. Danelutto, M. Vanneschi, P. Dazzi, D. Laforenza, N. Tonellotto, and P. Kilpatrick, “Behavioural skeletons in GCM: autonomic management of grid components,” in Proc. of intl. euromicro pdp 2008: parallel distributed and network-based processing, Toulouse, France, 2008, pp. 54-63. doi:10.1109/PDP.2008.46

Autonomic management can be used to improve the QoS provided by parallel/distributed applications. We discuss behavioural skeletons introduced in earlier work: rather than relying on programmer ability to design “from scratch” efficient autonomic policies, we encapsulate general autonomic controller features into algorithmic skeletons. Then we leave to the programmer the duty of specifying the parameters needed to specialise the skeletons to the needs of the particular application at hand. This results in the programmer having the ability to fast prototype and tune distributed/parallel applications with non-trivial autonomic management capabilities. We discuss how behavioural skeletons have been implemented in the framework of GCM (the grid component model developed within the CoreGRID NoE and currently being implemented within the GridCOMP STREP project). We present results evaluating the overhead introduced by autonomic management activities as well as the overall behaviour of the skeletons. We also present results achieved with a long running application subject to autonomic management and dynamically adapting to changing features of the target architecture. Overall the results demonstrate both the feasibility of implementing autonomic control via behavioural skeletons and the effectiveness of our sample behavioural skeletons in managing the “functional replication” pattern(s).

@inproceedings{orc:pdp:08,
abstract = {Autonomic management can be used to improve the QoS provided by parallel/distributed applications. We discuss behavioural skeletons introduced in earlier work: rather than relying on programmer ability to design "from scratch" efficient autonomic policies, we encapsulate general autonomic controller features into algorithmic skeletons. Then we leave to the programmer the duty of specifying the parameters needed to specialise the skeletons to the needs of the particular application at hand. This results in the programmer having the ability to fast prototype and tune distributed/parallel applications with non-trivial autonomic management capabilities. We discuss how behavioural skeletons have been implemented in the framework of GCM (the grid component model developed within the CoreGRID NoE and currently being implemented within the GridCOMP STREP project). We present results evaluating the overhead introduced by autonomic management activities as well as the overall behaviour of the skeletons. We also present results achieved with a long running application subject to autonomic management and dynamically adapting to changing features of the target architecture. Overall the results demonstrate both the feasibility of implementing autonomic control via behavioural skeletons and the effectiveness of our sample behavioural skeletons in managing the "functional replication" pattern(s).},
author = {Marco Aldinucci and Sonia Campa and Marco Danelutto and Marco Vanneschi and Patrizio Dazzi and Domenico Laforenza and Nicola Tonellotto and Peter Kilpatrick},
booktitle = {Proc. of Intl. Euromicro PDP 2008: Parallel Distributed and network-based Processing},
date-modified = {2009-02-05 23:55:55 +0100},
doi = {10.1109/PDP.2008.46},
editor = {Didier El Baz and Julien Bourgeois and Francois Spies},
month = feb,
pages = {54-63},
publisher = {IEEE},
title = {Behavioural skeletons in {GCM}: autonomic management of grid components},
year = {2008},
bdsk-url-2 = {http://dx.doi.org/10.1109/PDP.2008.46}
}

• M. Aldinucci, M. Torquati, M. Vanneschi, and P. Zuccato, “The virtualinux storage abstraction layer for efficient virtual clustering,” in Proc. of intl. euromicro pdp 2008: parallel distributed and network-based processing, Toulouse, France, 2008, pp. 619-627. doi:10.1109/PDP.2008.86

VirtuaLinux is a meta-distribution that enables a standard Linux distribution to support robust physical and virtualized clusters. VirtuaLinux helps in avoiding the “single point of failure” effect by means of a combination of architectural strategies, including the transparent support for disk-less and master-less cluster configuration. VirtuaLinux supports the creation and management of Virtual Clusters in seamless way: VirtuaLinux Virtual Cluster Manager enables the system administrator to create, save, restore Xen-based Virtual Clusters, and to map and dynamically re-map them onto the nodes of the physical cluster. In this paper we introduce and discuss VirtuaLinux virtualization architecture, features, and tools, and in particular, the novel disk abstraction layer, which permits the fast and space-efficient creation of Virtual Clusters.

@inproceedings{vlinux:pdp:08,
abstract = {VirtuaLinux is a meta-distribution that enables a standard Linux distribution to support robust physical and virtualized clusters. VirtuaLinux helps in avoiding the "single point of failure" effect by means of a combination of architectural strategies, including the transparent support for disk-less and master-less cluster configuration. VirtuaLinux supports the creation and management of Virtual Clusters in seamless way: VirtuaLinux Virtual Cluster Manager enables the system administrator to create, save, restore Xen-based Virtual Clusters, and to map and dynamically re-map them onto the nodes of the physical cluster. In this paper we introduce and discuss VirtuaLinux virtualization architecture, features, and tools, and in particular, the novel disk abstraction layer, which permits the fast and space-efficient creation of Virtual Clusters.},
author = {Marco Aldinucci and Massimo Torquati and Marco Vanneschi and Pierfrancesco Zuccato},
booktitle = {Proc. of Intl. Euromicro PDP 2008: Parallel Distributed and network-based Processing},
date-modified = {2009-11-10 01:29:09 +0100},
doi = {10.1109/PDP.2008.86},
editor = {Didier El Baz and Julien Bourgeois and Francois Spies},
month = feb,
pages = {619-627},
publisher = {IEEE},
title = {The VirtuaLinux Storage Abstraction Layer for Efficient Virtual Clustering},
year = {2008},
bdsk-url-1 = {http://dx.doi.org/10.1109/PDP.2008.86},
}

• M. Aldinucci, M. Danelutto, P. Kilpatrick, and P. Dazzi, “From Orc models to distributed grid Java code,” in Grid computing: achievements and prospects, S. Gorlatch, P. Fragopoulou, and T. Priol, Eds., Springer, 2008, pp. 13-24. doi:10.1007/978-0-387-09457-1_2

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.

@incollection{orc:IW_book:08,
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.},
author = {Marco Aldinucci and Marco Danelutto and Peter Kilpatrick and Patrizio Dazzi},
booktitle = {Grid Computing: Achievements and Prospects},
date-modified = {2015-02-21 14:30:35 +0000},
doi = {10.1007/978-0-387-09457-1_2},
editor = {Sergei Gorlatch and Paraskevi Fragopoulou and Thierry Priol},
isbn = {978-0-387-09456-4},
pages = {13-24},
publisher = {Springer},
series = {CoreGRID},
title = {From {Orc} Models to Distributed Grid {Java} code},
year = {2008},
bdsk-url-2 = {http://dx.doi.org/10.1007/978-0-387-09457-1},
bdsk-url-3 = {http://dx.doi.org/10.1007/978-0-387-09457-1_2}
}

• M. Aldinucci, M. Danelutto, and P. Kilpatrick, “A framework for prototyping and reasoning about grid systems,” in Parallel computing: architectures, algorithms and applications, Germany, 2008, pp. 235-242.

A framework supporting fast prototyping as well as tuning of distributed applications is presented. The approach is based on the adoption of a formal model that is used to describe the orchestration of distributed applications. The formal model (Orc by Misra and Cook) can be used to support semi-formal reasoning about the applications at hand. The paper describes how the framework can be used to derive and evaluate alternative orchestrations of a well know parallel/distributed computation pattern; and shows how the same formal model can be used to support generation of prototypes of distributed applications skeletons directly from the application description.

@inproceedings{orc:parco:07,
abstract = {A framework supporting fast prototyping as well as tuning of distributed applications is presented. The approach is based on the adoption of a formal model that is used to describe the orchestration of distributed applications. The formal model (Orc by Misra and Cook) can be used to support semi-formal reasoning about the applications at hand. The paper describes how the framework can be used to derive and evaluate alternative orchestrations of a well know parallel/distributed computation pattern; and shows how the same formal model can be used to support generation of prototypes of distributed applications skeletons directly from the application description.},
annote = {Parco 2007},
author = {Marco Aldinucci and Marco Danelutto and Peter Kilpatrick},
booktitle = {Parallel Computing: Architectures, Algorithms and Applications},
date-modified = {2012-11-18 17:48:22 +0000},
editor = {C. Bischof and M. B{\"u}cker and P. Gibbon and G. R. Joubert and T. Lippert and B. Mohr and F. J. Peters},
isbn = {9781586037963},
pages = {235-242},
publisher = {IOS press},
series = {ADVANCES IN PARALLEL COMPUTING},
title = {A framework for prototyping and reasoning about grid systems},
volume = {15},
year = {2008},
}

• M. Aldinucci, M. Danelutto, M. Torquati, F. Polzella, G. Spinatelli, M. Vanneschi, A. Gervaso, M. Cacitti, and P. Zuccato, “VirtuaLinux: virtualized high-density clusters with no single point of failure,” in Parallel computing: architectures, algorithms and applications, The Netherlands, 2008, pp. 355-362.

VirtuaLinux is a Linux meta-distribution that allows the creation, deployment and administration of both physical and virtualized clusters with no single point of failure. VirtuaLinux supports the creation and management of virtual clusters in seamless way: VirtuaLinux Virtual Cluster Manager enables the system administrator to create, save, restore Xen-based virtual clusters, and to map and dynamically remap them onto the nodes of the physical cluster. We introduces and discuss VirtuaLinux virtualization architecture, features, and tools. These rely on a novel disk abstraction layer, which enables the fast, space-efficient, dynamic creation of virtual clusters composed of fully independent complete virtual machines.

@inproceedings{virtualinux:parco:07,
abstract = {VirtuaLinux is a Linux meta-distribution that allows the creation, deployment and administration of both physical and virtualized clusters with no single point of failure. VirtuaLinux supports the creation and management of virtual clusters in seamless way: VirtuaLinux Virtual Cluster Manager enables the system administrator to create, save, restore Xen-based virtual clusters, and to map and dynamically remap them onto the nodes of the physical cluster. We introduces and discuss VirtuaLinux virtualization architecture, features, and tools. These rely on a novel disk abstraction layer, which enables the fast, space-efficient, dynamic creation of virtual clusters composed of fully independent complete virtual machines.},
annote = {Parco 2007},
author = {Marco Aldinucci and Marco Danelutto and Massimo Torquati and Francesco Polzella and Gianmarco Spinatelli and Marco Vanneschi and Alessandro Gervaso and Manuel Cacitti and Pierfrancesco Zuccato},
booktitle = {Parallel Computing: Architectures, Algorithms and Applications},
date-modified = {2012-11-18 17:56:09 +0000},
editor = {C. Bischof and M. B{\"u}cker and P. Gibbon and G. R. Joubert and T. Lippert and B. Mohr and F. J. Peters},
pages = {355-362},
publisher = {IOS press},
series = {ADVANCES IN PARALLEL COMPUTING},
title = {{VirtuaLinux}: virtualized high-density clusters with no single point of failure},
volume = {15},
year = {2008},
}

### 2007

• M. Aldinucci, M. Danelutto, and P. Dazzi, “Muskel: an expandable skeleton environment,” Scalable computing: practice and experience, vol. 8, iss. 4, pp. 325-341, 2007.

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.

@article{muskel:SCPE:07,
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.},
author = {Marco Aldinucci and Marco Danelutto and Patrizio Dazzi},
date-modified = {2014-08-24 22:17:35 +0000},
journal = {Scalable Computing: Practice and Experience},
month = dec,
number = {4},
pages = {325-341},
title = {MUSKEL: an expandable skeleton environment},
url = {http://www.scpe.org/index.php/scpe/article/view/429},
volume = {8},
year = {2007},
bdsk-url-1 = {http://www.scpe.org/vols/vol08/no4/SCPE_8_4_01.pdf},
bdsk-url-3 = {http://www.scpe.org/index.php/scpe/article/view/429}
}

• M. Aldinucci and M. Danelutto, “Skeleton based parallel programming: functional and parallel semantic in a single shot,” Computer languages, systems and structures, vol. 33, iss. 3-4, pp. 179-192, 2007. doi:10.1016/j.cl.2006.07.004

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.

@article{lithium:sem:CLSS,
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.},
annote = {ISSN: 1477-8424},
author = {Marco Aldinucci and Marco Danelutto},
date-modified = {2014-08-24 22:17:22 +0000},
doi = {10.1016/j.cl.2006.07.004},
journal = {Computer Languages, Systems and Structures},
month = oct,
number = {3-4},
pages = {179-192},
title = {Skeleton based parallel programming: functional and parallel semantic in a single shot},
volume = {33},
year = {2007},
bdsk-url-2 = {http://dx.doi.org/10.1016/j.cl.2006.07.004}
}

• M. Aldinucci, M. Danelutto, and P. Kilpatrick, “Adding metadata to orc to support reasoning about grid programming,” in Towards next generation grids (proc. of the coregrid symposium 2007), Rennes, France, 2007, pp. 205-214. doi:10.1007/978-0-387-72498-0_19

Following earlier work demonstrating the utility of Orc as a means of specifying and reasoning about grid applications we propose the enhancement of such specifications with metadata that provide a means to extend an Orc specification with implementation oriented information. We argue that such specifications provide a useful refinement step in allowing reasoning about implementation related issues ahead of actual implementation or even prototyping. As examples, we demonstrate how such extended specifications can be used for investigating security related issues and for evaluating the cost of handling grid resource faults. The approach emphasises a semi-formal style of reasoning that makes maximum use of programmer domain knowledge and experience.

@inproceedings{orc:metadata:cgs:07,
abstract = {Following earlier work demonstrating the utility of Orc as a means of specifying and reasoning about grid applications we propose the enhancement of such specifications with metadata that provide a means to extend an Orc specification with implementation oriented information. We argue that such specifications provide a useful refinement step in allowing reasoning about implementation related issues ahead of actual implementation or even prototyping. As examples, we demonstrate how such extended specifications can be used for investigating security related issues and for evaluating the cost of handling grid resource faults. The approach emphasises a semi-formal style of reasoning that makes maximum use of programmer domain knowledge and experience.},
author = {Marco Aldinucci and Marco Danelutto and Peter Kilpatrick},
booktitle = {Towards Next Generation Grids (Proc. of the CoreGRID Symposium 2007)},
date-modified = {2009-02-04 18:57:20 +0100},
doi = {10.1007/978-0-387-72498-0_19},
editor = {Thierry Priol and Marco Vanneschi},
isbn = {978-0-387-72497-3},
month = sep,
pages = {205-214},
publisher = {Springer},
series = {CoreGRID},
year = {2007},
bdsk-url-2 = {http://dx.doi.org/10.1007/978-0-387-72498-0_19}
}

• M. Aldinucci, M. Danelutto, and P. Kilpatrick, “Management in distributed systems: a semi-formal approach,” in Proc. of 13th intl. euro-par 2007 parallel processing, Rennes, France, 2007, pp. 651-661. doi:10.1007/978-3-540-74466-5

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.

@inproceedings{orc:europar:07,
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.},
author = {Marco Aldinucci and Marco Danelutto and Peter Kilpatrick},
booktitle = {Proc. of 13th Intl. Euro-Par 2007 Parallel Processing},
date-modified = {2009-05-01 23:33:34 +0200},
doi = {10.1007/978-3-540-74466-5},
editor = {A.-M. Kermarrec and L. Boug{\'e} and T. Priol},
isbn = {978-3-540-74465-8},
month = aug,
pages = {651-661},
publisher = {Springer},
series = {LNCS},
title = {Management in distributed systems: a semi-formal approach},
volume = {4641},
year = {2007},
bdsk-url-2 = {http://dx.doi.org/10.1007/978-3-540-74466-5}
}

• M. Aldinucci, S. Campa, M. Danelutto, P. Dazzi, P. Kilpatrick, D. Laforenza, and N. Tonellotto, “Behavioural skeletons for component autonomic management on grids,” in Coregrid workshop on grid programming model, grid and p2p systems architecture, grid systems, tools and environments, Heraklion, Crete, Greece, 2007.

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.

@inproceedings{beske:cg:heraklion:07,
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.},
author = {Marco Aldinucci and Sonia Campa and Marco Danelutto and Patrizio Dazzi and Peter Kilpatrick and Domenico Laforenza and Nicola Tonellotto},
booktitle = {CoreGRID Workshop on Grid Programming Model, Grid and P2P Systems Architecture, Grid Systems, Tools and Environments},
date-modified = {2007-12-16 23:32:27 +0100},
month = {jun},
title = {Behavioural skeletons for component autonomic management on grids},
url = {http://compass2.di.unipi.it/TR/Files/TR-07-12.pdf.gz},
year = {2007},
bdsk-url-1 = {http://compass2.di.unipi.it/TR/Files/TR-07-12.pdf.gz}
}

• M. Aldinucci, S. Campa, P. Dazzi, and N. Tonellotto, D.NFCF.01 – non functional component subsystem architectural design, 2007.
[BibTeX]
@misc{gridcomp:D.NFCF.01,
author = {Marco Aldinucci and Sonia Campa and Patrizio Dazzi and Nicola Tonellotto},
date-modified = {2008-09-19 15:54:12 +0200},
howpublished = {\url{ http://gridcomp.ercim.org/}},
month = jun,
title = {{D.NFCF.01} -- Non functional component subsystem architectural design},
year = {2007}
}

• M. Aldinucci, S. Campa, P. Dazzi, and N. Tonellotto, D.NFCF.02 – non functional component subsystem architectural design (code), 2007.
[BibTeX]
@misc{gridcomp:D.NFCF.02,
author = {Marco Aldinucci and Sonia Campa and Patrizio Dazzi and Nicola Tonellotto},
date-modified = {2008-09-19 15:54:36 +0200},
howpublished = {\url{ http://gridcomp.ercim.org/}},
month = jun,
title = {{D.NFCF.02} -- Non functional component subsystem architectural design (code)},
year = {2007}
}

• M. Aldinucci and P. Zuccato, “Virtual clusters with no single point of failure,” in Intl. supercomputing conference (isc2007), poster session, Dresden, Germany, 2007.

VirtuaLinux is a Linux meta-distribution that allows the creation, deployment and administration of virtualized clusters with no single point of failure. VirtuaLinux architecture supports diskless configurations and provides an efficient, iSCSI based abstraction of the SAN. Clusters running VirtuaLinux exhibit no master node, thus boosting resilience and flexibility.

@inproceedings{virtualinux:poster:ics:07,
abstract = {VirtuaLinux is a Linux meta-distribution that allows the creation, deployment and administration of virtualized clusters with no single point of failure. VirtuaLinux architecture supports diskless configurations and provides an efficient, iSCSI based abstraction of the SAN. Clusters running VirtuaLinux exhibit no master node, thus boosting resilience and flexibility.},
author = {Marco Aldinucci and Pierfrancesco Zuccato},
booktitle = {Intl. Supercomputing Conference (ISC2007), Poster session},
date-modified = {2007-11-03 14:28:15 +0100},
month = jun,
title = {Virtual clusters with no single point of failure},
year = {2007},
}

• M. Aldinucci and M. Danelutto, “The cost of security in skeletal systems,” in Proc. of intl. euromicro pdp 2007: parallel distributed and network-based processing, Napoli, Italia, 2007, pp. 213-220. doi:10.1109/PDP.2007.79

Skeletal systems exploit algorithmical skeletons technology to provide the user very high level, efficient parallel programming environments. They have been recently demonstrated to be suitable for highly distributed architectures, such as workstation clusters, networks and grids. However, when using skeletal system for grid programming care must be taken to secure data and code transfers across non-dedicated, non-secure network links. In this work we take into account the cost of security introduction in muskel, a Java based skeletal system exploiting macro data flow implementation technology. We consider the adoption of mechanisms that allow securing all the communications taking place between remote, unreliable nodes and we evaluate the cost of such mechanisms. In particular, we consider the implications on the computational grains needed to scale secure and insecure skeletal computations.

@inproceedings{security:euromicro:07,
abstract = {Skeletal systems exploit algorithmical skeletons technology to provide the user very high level, efficient parallel programming environments. They have been recently demonstrated to be suitable for highly distributed architectures, such as workstation clusters, networks and grids. However, when using skeletal system for grid programming care must be taken to secure data and code transfers across non-dedicated, non-secure network links. In this work we take into account the cost of security introduction in muskel, a Java based skeletal system exploiting macro data flow implementation technology. We consider the adoption of mechanisms that allow securing all the communications taking place between remote, unreliable nodes and we evaluate the cost of such mechanisms. In particular, we consider the implications on the computational grains needed to scale secure and insecure skeletal computations.},
author = {Marco Aldinucci and Marco Danelutto},
booktitle = {Proc. of Intl. Euromicro PDP 2007: Parallel Distributed and network-based Processing},
date-modified = {2008-02-18 12:49:23 +0100},
doi = {10.1109/PDP.2007.79},
editor = {Pasqua D'Ambra and Mario Rosario Guarracino},
month = feb,
pages = {213-220},
publisher = {IEEE},
title = {The cost of security in skeletal systems},
year = {2007},
bdsk-url-2 = {http://dx.doi.org/10.1109/PDP.2007.79}
}

• M. Aldinucci, S. Campa, M. Coppola, M. Danelutto, C. Zoccolo, F. André, and J. Buisson, “An abstract schema modeling adaptivity management,” in Integrated research in grid computing, S. Gorlatch and M. Danelutto, Eds., Springer, 2007, pp. 89-102. doi:10.1007/978-0-387-47658-2_7

Nowadays, component application adaptivity in Grid environments has been afforded in different ways, such those provided by the Dynaco/AFPAC framework and by the ASSIST environment. We propose an abstract schema that catches all the designing aspects a model for parallel component applications on Grid should define in order to uniformly handle the dynamic behavior of computing resources within complex parallel applications. The abstraction is validated by demonstrating how two different approaches to adaptivity, ASSIST and Dynaco/AFPAC, easily map to such schema.

@incollection{adapt_rennes:IW_book:06,
abstract = {Nowadays, component application adaptivity in Grid environments has been afforded in different ways, such those provided by the Dynaco/AFPAC framework and by the ASSIST environment. We propose an abstract schema that catches all the designing aspects a model for parallel component applications on Grid should define in order to uniformly handle the dynamic behavior of computing resources within complex parallel applications. The abstraction is validated by demonstrating how two different approaches to adaptivity, ASSIST and Dynaco/AFPAC, easily map to such schema.},
annote = {ISBN: 0-387-47656-3},
author = {Marco Aldinucci and Sonia Campa and Massimo Coppola and Marco Danelutto and Corrado Zoccolo and Francoise Andr{\'e} and J{\'e}r{\'e}my Buisson},
booktitle = {Integrated Research in Grid Computing},
date-modified = {2012-03-18 00:36:49 +0000},
doi = {10.1007/978-0-387-47658-2_7},
editor = {Sergei Gorlatch and Marco Danelutto},
isbn = {978-0-387-47656-8},
owner = {aldinuc},
pages = {89-102},
publisher = {Springer},
series = {CoreGRID},
timestamp = {2006.06.28},
title = {An abstract schema modeling adaptivity management},
year = {2007},
bdsk-url-2 = {http://dx.doi.org/10.1007/978-0-387-47658-2_7}
}

• M. Aldinucci and A. Benoit, “Towards the automatic mapping of ASSIST applications for the grid,” in Integrated research in grid computing, S. Gorlatch and M. Danelutto, Eds., Springer, 2007, pp. 73-87. doi:10.1007/978-0-387-47658-2_6

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.

@incollection{assist:pepa:IW_book:06,
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.},
author = {Marco Aldinucci and Anne Benoit},
booktitle = {Integrated Research in Grid Computing},
date-modified = {2009-02-01 17:26:53 +0100},
doi = {10.1007/978-0-387-47658-2_6},
editor = {Sergei Gorlatch and Marco Danelutto},
isbn = {978-0-387-47656-8},
owner = {aldinuc},
pages = {73-87},
publisher = {Springer},
series = {CoreGRID},
timestamp = {2006.06.28},
title = {Towards the Automatic Mapping of {ASSIST} Applications for the Grid},
year = {2007},
bdsk-url-2 = {http://dx.doi.org/10.1007/978-0-387-47658-2_6}
}

• J. Dünnweber, S. Gorlatch, S. Campa, M. Aldinucci, and M. Danelutto, “Adaptable parallel components for grid programming,” in Integrated research in grid computing, S. Gorlatch and M. Danelutto, Eds., Springer, 2007, pp. 43-57. doi:10.1007/978-0-387-47658-2_4

We suggest that parallel software components used for grid computing should be adaptable to application-specific requirements, instead of developing new components from scratch for each particular application. As an example, we take a parallel farm component which is “embarrassingly parallel”, i. e. , free of dependencies, and adapt it to the wavefront processing pattern with dependencies that impact its behavior. We describe our approach in the context of Higher-Order Components (HOCs), with the Java-based system Lithium as our implementation framework. The adaptation process relies on HOCs’ mobile code parameters that are shipped over the network of the grid. We describe our implementation of the proposed component adaptation method and report first experimental results for a particular grid application – the alignment of DNA sequence pairs, a popular, time-critical problem in computational molecular biology.

@incollection{codeadapt:IW_book:06,
abstract = {We suggest that parallel software components used for grid computing should be adaptable to application-specific requirements, instead of developing new components from scratch for each particular application. As an example, we take a parallel farm component which is "embarrassingly parallel", i. e. , free of dependencies, and adapt it to the wavefront processing pattern with dependencies that impact its behavior. We describe our approach in the context of Higher-Order Components (HOCs), with the Java-based system Lithium as our implementation framework. The adaptation process relies on HOCs' mobile code parameters that are shipped over the network of the grid. We describe our implementation of the proposed component adaptation method and report first experimental results for a particular grid application -- the alignment of DNA sequence pairs, a popular, time-critical problem in computational molecular biology.},
author = {Jan D{\"u}nnweber and Sergei Gorlatch and Sonia Campa and Marco Aldinucci and Marco Danelutto},
booktitle = {Integrated Research in Grid Computing},
date-modified = {2009-02-01 17:56:57 +0100},
doi = {10.1007/978-0-387-47658-2_4},
editor = {Sergei Gorlatch and Marco Danelutto},
isbn = {978-0-387-47656-8},
pages = {43-57},
publisher = {Springer},
series = {CoreGRID},
timestamp = {2006.06.28},
title = {Adaptable Parallel Components for Grid Programming},
year = {2007},
bdsk-url-2 = {http://dx.doi.org/10.1007/978-0-387-47658-2_4}
}

• M. Pasin, P. Kuonen, M. Danelutto, and M. Aldinucci, “Skeleton parallel programming and parallel objects,” in Integrated research in grid computing, S. Gorlatch and M. Danelutto, Eds., Springer, 2007, pp. 59-71. doi:10.1007/978-0-387-47658-2_5

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.

@incollection{pasin:IW_book:06,
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.},
annote = {ISBN: 978-0-387-47656-8},
author = {Marcelo Pasin and Pierre Kuonen and Marco Danelutto and Marco Aldinucci},
booktitle = {Integrated Research in Grid Computing},
date-modified = {2009-02-01 17:51:38 +0100},
doi = {10.1007/978-0-387-47658-2_5},
editor = {Sergei Gorlatch and Marco Danelutto},
isbn = {978-0-387-47656-8},
owner = {aldinuc},
pages = {59-71},
publisher = {Springer},
series = {CoreGRID},
timestamp = {2006.06.28},
title = {Skeleton Parallel Programming and Parallel Objects},
year = {2007},
bdsk-url-2 = {http://dx.doi.org/10.1007/978-0-387-47658-2_5}
}

### 2006

• M. Aldinucci, M. Danelutto, A. Paternesi, R. Ravazzolo, and M. Vanneschi, “Building interoperable grid-aware ASSIST applications via WebServices,” in Parallel computing: current & future issues of high-end computing (proc. of PARCO 2005, malaga, spain), Germany, 2006, pp. 145-152.

The ASSIST environment provides a high-level programming toolkit for the grid. ASSIST applications are described by means of a coordination language, which can express arbitrary graphs of modules. These modules (or a graph of them) may be enclosed in components specifically designed for the grid (GRID.it components). In this paper we describe how ASSIST modules can be wired through standard Web Services, and how GRID.it components may be made available as standard Web Services.

@inproceedings{assist:webs:parco:05,
abstract = {The ASSIST environment provides a high-level programming toolkit for the grid. ASSIST applications are described by means of a coordination language, which can express arbitrary graphs of modules. These modules (or a graph of them) may be enclosed in components specifically designed for the grid (GRID.it components). In this paper we describe how ASSIST modules can be wired through standard Web Services, and how GRID.it components may be made available as standard Web Services.},
author = {Marco Aldinucci and Marco Danelutto and Andrea Paternesi and Roberto Ravazzolo and Marco Vanneschi},
booktitle = {Parallel Computing: Current \& Future Issues of High-End Computing (Proc. of {PARCO 2005}, Malaga, Spain)},
date-modified = {2012-11-18 17:06:42 +0000},
editor = {G. R. Joubert and W. E. Nagel and F. J. Peters and O. Plata and P. Tirado and E. Zapata},
isbn = {3000173528},
month = dec,
pages = {145-152},
publisher = {John von Neumann Institute for Computing},
series = {NIC},
title = {Building interoperable grid-aware {ASSIST} applications via {WebServices}},
volume = {33},
year = {2006},
}

• M. Aldinucci, M. Danelutto, G. Giaccherini, M. Torquati, and M. Vanneschi, “Towards a distributed scalable data service for the grid,” in Parallel computing: current & future issues of high-end computing (proc. of PARCO 2005, malaga, spain), Germany, 2006, pp. 73-80.

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.

@inproceedings{adhoc:parco:05,
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.},
author = {Marco Aldinucci and Marco Danelutto and Gianni Giaccherini and Massimo Torquati and Marco Vanneschi},
booktitle = {Parallel Computing: Current \& Future Issues of High-End Computing (Proc. of {PARCO 2005}, Malaga, Spain)},
date-modified = {2012-11-18 17:07:26 +0000},
editor = {G. R. Joubert and W. E. Nagel and F. J. Peters and O. Plata and P. Tirado and E. Zapata},
month = dec,
optannote = {ISBN: 3-00-017352-8},
pages = {73-80},
publisher = {John von Neumann Institute for Computing},
series = {NIC},
title = {Towards a distributed scalable data service for the grid},
volume = {33},
year = {2006},
}

• M. Aldinucci, C. Bertolli, S. Campa, M. Coppola, M. Vanneschi, L. Veraldi, and C. Zoccolo, “Self-configuring and self-optimizing grid components in the GCM model and their ASSIST implementation,” in Proc. of. hpc-geco/compframe (held in conjunction with hpdc-15), Paris, France, 2006, pp. 45-52.

We present the concept of autonomic super-component as a building block for Grid-aware applications. Super-components are parametric, higher-order components exhibiting a well-known parallel behaviour. The proposal of a super-component feature is part of the experience we gained in the implementation of the ASSIST environment, which allows the development of self-configuring and optimising component-based applications following a structured and hierarchical approach. We discuss how such approach to Grid programming influenced the design of the Grid Component Model (GCM).

@inproceedings{selfadapt:hpcgeco:06,
abstract = {We present the concept of autonomic super-component as a building block for Grid-aware applications. Super-components are parametric, higher-order components exhibiting a well-known parallel behaviour. The proposal of a super-component feature is part of the experience we gained in the implementation of the ASSIST environment, which allows the development of self-configuring and optimising component-based applications following a structured and hierarchical approach. We discuss how such approach to Grid programming influenced the design of the Grid Component Model (GCM).},
author = {Marco Aldinucci and Carlo Bertolli and Sonia Campa and Massimo Coppola and Marco Vanneschi and Luca Veraldi and Corrado Zoccolo},
booktitle = {Proc. of. HPC-GECO/Compframe (held in conjunction with HPDC-15)},
date-modified = {2014-08-25 15:06:03 +0000},
month = jun,
owner = {aldinuc},
pages = {45-52},
publisher = {IEEE},
timestamp = {2006.06.28},
title = {Self-configuring and self-optimizing grid components in the {GCM} model and their {ASSIST} implementation},
year = {2006},
}

• M. Aldinucci, M. Danelutto, and M. Vanneschi, “Autonomic QoS in ASSIST grid-aware components,” in Proc. of intl. euromicro pdp 2006: parallel distributed and network-based processing, Montbéliard, France, 2006, pp. 221-230. doi:10.1109/PDP.2006.25

Current Grid-aware applications are developed on existing software infrastructures, such as Globus, by developers who are experts on Grid software implementation. Although many useful applications have been produced this way, this approach may hardly support the additional complexity to Quality of Service (QoS) control in real application. We describe the ASSIST programming environment, the prototype of parallel programming environment currently under development at our group, as a suitable basis to capture all the desired features for QoS control for the Grid. Grid applications, built as compositions of ASSIST components, are supported by an innovative Grid Abstract Machine, which includes essential abstractions of standard middleware services and a hierarchical Application Manager, which may be considered as an early prototype of Autonomic Manager.

@inproceedings{assist:qos:euromicro:06,
abstract = {Current Grid-aware applications are developed on existing software infrastructures, such as Globus, by developers who are experts on Grid software implementation. Although many useful applications have been produced this way, this approach may hardly support the additional complexity to Quality of Service (QoS) control in real application. We describe the ASSIST programming environment, the prototype of parallel programming environment currently under development at our group, as a suitable basis to capture all the desired features for QoS control for the Grid. Grid applications, built as compositions of ASSIST components, are supported by an innovative Grid Abstract Machine, which includes essential abstractions of standard middleware services and a hierarchical Application Manager, which may be considered as an early prototype of Autonomic Manager.},
author = {Marco Aldinucci and Marco Danelutto and Marco Vanneschi},
booktitle = {Proc. of Intl. Euromicro PDP 2006: Parallel Distributed and network-based Processing},
date-modified = {2012-11-18 16:14:35 +0000},
doi = {10.1109/PDP.2006.25},
month = feb,
pages = {221-230},
publisher = {IEEE},
title = {Autonomic {QoS} in {ASSIST} Grid-aware components},
year = {2006},
bdsk-url-2 = {http://dx.doi.org/10.1109/PDP.2006.25}
}

• M. Aldinucci, M. Coppola, M. Danelutto, M. Vanneschi, and C. Zoccolo, “ASSIST as a research framework for high-performance grid programming environments,” in Grid computing: software environments and tools, J. C. Cunha and O. F. Rana, Eds., Springer, 2006, pp. 230-256. doi:10.1007/1-84628-339-6_10

ASSIST is a programming environment supporting the development of parallel and distributed high-performance applications on a wide range of target architectures including massively parallel clusters/networks of workstations and Grids. We discuss how ASSIST can act as a valid research vehicle to study, experiment and realize Grid-aware programming environments for high-performance applications. Special emphasis is put on the innovative methodologies, strategies and tools for dynamically adaptive applications that represent the necessary step for the success of Grid platforms. We start considering which are the fundamental features of Grid-aware programming environments, based upon structured parallel programming and components technology. Then we show how ASSIST evolved from its very first version, only targeting workstation clusters, to the current version, targeting Grids and solving many critical problems related to expressive power, flexibility, interoperability and efficiency. We also discuss how ASSIST deals with interoperability issues. Eventually we discuss how an ASSIST-based model for supporting dynamically adaptive applications can be derived.

@incollection{assist:cunhabook:05,
abstract = {ASSIST is a programming environment supporting the development of parallel and distributed high-performance applications on a wide range of target architectures including massively parallel clusters/networks of workstations and Grids. We discuss how ASSIST can act as a valid research vehicle to study, experiment and realize Grid-aware programming environments for high-performance applications. Special emphasis is put on the innovative methodologies, strategies and tools for dynamically adaptive applications that represent the necessary step for the success of Grid platforms.
We start considering which are the fundamental features of Grid-aware programming environments, based upon structured parallel programming and components technology. Then we show how ASSIST evolved from its very first version, only targeting workstation clusters, to the current version, targeting Grids and solving many critical problems related to expressive power, flexibility, interoperability and efficiency. We also discuss how ASSIST deals with interoperability issues. Eventually we discuss how an ASSIST-based model for supporting dynamically adaptive applications can be derived.},
author = {Marco Aldinucci and Massimo Coppola and Marco Danelutto and Marco Vanneschi and Corrado Zoccolo},
booktitle = {Grid Computing: Software environments and Tools},
chapter = {10},
date-modified = {2014-06-22 10:12:07 +0000},
doi = {10.1007/1-84628-339-6_10},
editor = {J. C. Cunha and O. F. Rana},
isbn = {978-1-85233-998-2},
month = jan,
pages = {230-256},
publisher = {Springer},
title = {{ASSIST} as a research framework for high-performance Grid programming environments},
year = {2006},
bdsk-url-2 = {https://doi.org/10.1007/1-84628-339-6_10}
}

• M. Aldinucci, F. André, J. Buisson, S. Campa, M. Coppola, M. Danelutto, and C. Zoccolo, “Parallel program/component adaptivity management,” in Parallel computing: current & future issues of high-end computing (proc. of PARCO 2005, malaga, spain), Germany, 2006, pp. 89-96.

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.

@inproceedings{adaptivity:parco:05,
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.},
author = {Marco Aldinucci and Francoise Andr{\'e} and J{\'e}r{\'e}my Buisson and Sonia Campa and Massimo Coppola and Marco Danelutto and Corrado Zoccolo},
booktitle = {Parallel Computing: Current \& Future Issues of High-End Computing (Proc. of {PARCO 2005}, Malaga, Spain)},
date-modified = {2012-11-18 17:08:30 +0000},
editor = {G. R. Joubert and W. E. Nagel and F. J. Peters and O. Plata and P. Tirado and E. Zapata},
month = dec,
optannote = {ISBN: 3-00-017352-8},
pages = {89-96},
publisher = {John von Neumann Institute for Computing},
series = {NIC},
title = {Parallel program/component adaptivity management},
volume = {33},
year = {2006},
}

• M. Aldinucci and M. Danelutto, “Algorithmic skeletons meeting grids,” Parallel computing, vol. 32, iss. 7, pp. 449-462, 2006. doi:10.1016/j.parco.2006.04.001

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.

@article{advske:pc:06,
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.},
author = {Marco Aldinucci and Marco Danelutto},
date-modified = {2008-02-07 03:38:19 +0100},
doi = {10.1016/j.parco.2006.04.001},
journal = {Parallel Computing},
number = {7},
pages = {449-462},
title = {Algorithmic skeletons meeting grids},
volume = {32},
year = {2006},
bdsk-url-2 = {https://doi.org/10.1016/j.parco.2006.04.001}
}

• M. Aldinucci, M. Coppola, M. Danelutto, N. Tonellotto, M. Vanneschi, and C. Zoccolo, “High level grid programming with ASSIST,” Computational methods in science and technology, vol. 12, iss. 1, pp. 21-32, 2006.

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.

@article{assist:CMST:06,
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.},
annote = {ISSN: 1505-0602},
author = {Marco Aldinucci and Massimo Coppola and Marco Danelutto and Nicola Tonellotto and Marco Vanneschi and Corrado Zoccolo},
date-modified = {2012-08-14 15:26:55 +0000},
journal = {Computational Methods in Science and Technology},
number = {1},
owner = {aldinuc},
pages = {21-32},
title = {High level grid programming with {ASSIST}},
volume = {12},
year = {2006},
}

• M. Aldinucci, M. Coppola, S. Campa, M. Danelutto, M. Vanneschi, and C. Zoccolo, “Structured implementation of component based grid programming environments,” in Future generation grids, V. Getov, D. Laforenza, and A. Reinefeld, Eds., Springer, 2006, pp. 217-239. doi:10.1007/978-0-387-29445-2_12

The design,implementation and deployment of efficient high performance applications on Grids is usually a quite hard task, even in the case that modern and efficient grid middleware systems are used. We claim that most of the difficulties involved in such process can be moved away from programmer responsibility by following a structured programming model approach. The proposed approach relies on the development of a layered, component based execution environment. Each layer deals with distinct features and problems related to the implementation of GRID applications, exploiting the more appropriate techniques. Static optimizations are introduced in the compile layer, dynamic optimization are introduced in the run time layer, whereas modern grid middleware features are simply exploited using standard middleware systems as the final target architecture. We first discuss the general idea, then we discuss the peculiarities of the approach and eventually we discuss the preliminary results achieved in the GRID.it project, where a prototype high performance, component based, GRID programming environment is being developed using this approach.

@incollection{assist:dagstuhl:05,
abstract = {The design,implementation and deployment of efficient high performance applications on Grids is usually a quite hard task, even in the case that modern and efficient grid middleware systems are used. We claim that most of the difficulties involved in such process can be moved away from programmer responsibility by following a structured programming model approach. The proposed approach relies on the development of a layered, component based execution environment. Each layer deals with distinct features and problems related to the implementation of GRID applications, exploiting the more appropriate techniques. Static optimizations are introduced in the compile layer, dynamic optimization are introduced in the run time layer, whereas modern grid middleware features are simply exploited using standard middleware systems as the final target architecture. We first discuss the general idea, then we discuss the peculiarities of the approach and eventually we discuss the preliminary results achieved in the GRID.it project, where a prototype high performance, component based, GRID programming environment is being developed using this approach.},
author = {Marco Aldinucci and Massimo Coppola and Sonia Campa and Marco Danelutto and Marco Vanneschi and Corrado Zoccolo},
booktitle = {Future Generation Grids},
date-modified = {2012-11-24 09:27:00 +0000},
doi = {10.1007/978-0-387-29445-2_12},
editor = {Vladimir Getov and Domenico Laforenza and Alexander Reinefeld},
isbn = {978-0-387-27935-0},
pages = {217-239},
publisher = {Springer},
series = {CoreGRID},
title = {Structured implementation of component based grid programming environments},
year = {2006},
bdsk-url-2 = {https://doi.org/10.1007/978-0-387-29445-2_12}
}

• M. Aldinucci, G. Antoniu, M. Danelutto, and M. Jan, “Fault-tolerant data sharing for high-level grid programming: a hierarchical storage architecture,” in Proc. of the integrated research in grid computing workshop, Kraków, Poland, 2006, pp. 177-188.

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).

@inproceedings{assist:juxmem:IW:06,
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).},
author = {Marco Aldinucci and Gabriel Antoniu and Marco Danelutto and Mathieu Jan},
booktitle = {Proc. of the Integrated Research in Grid Computing Workshop},
date-modified = {2012-11-18 17:23:11 +0000},
editor = {Marian Bubak and Sergei Gorlatch and Thierry Priol},
keywords = {Duplicate},
month = oct,
optannote = {ISBN: 83-9115141-6-1},
pages = {177-188},
publisher = {Academic Computing Centre {CYFRONET AGH}},
series = {CoreGRID},
title = {Fault-Tolerant Data Sharing for High-level Grid Programming: A Hierarchical Storage Architecture},
year = {2006},
}

### 2005

• M. Aldinucci, F. André, J. Buisson, S. Campa, M. Coppola, M. Danelutto, and C. Zoccolo, “Parallel program/component adaptivity management,” in Proc. of the integrated research in grid computing workshop, Pisa, Italy, 2005, pp. 95-104.

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.

@inproceedings{adaptivity:IW:05,
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.},
author = {Marco Aldinucci and Francoise Andr{\'e} and J{\'e}r{\'e}my Buisson and Sonia Campa and Massimo Coppola and Marco Danelutto and Corrado Zoccolo},
booktitle = {Proc. of the Integrated Research in Grid Computing Workshop},
date-modified = {2012-11-18 17:04:16 +0000},
editor = {Sergei Gorlatch and Marco Danelutto},
keywords = {Duplicate},
month = nov,
pages = {95-104},
publisher = {Universit{\a} di Pisa, Dipartimento di Informatica},
title = {Parallel program/component adaptivity management},
volume = {TR-05-22},
year = {2005},
}

• M. Aldinucci and A. Benoit, “Towards the automatic mapping of ASSIST applications for the grid,” in Proc. of the integrated research in grid computing workshop, Pisa, Italy, 2005, pp. 59-68.

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.

@inproceedings{assist:pepa:IW:05,
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.},
author = {Marco Aldinucci and Anne Benoit},
booktitle = {Proc. of the Integrated Research in Grid Computing Workshop},
editor = {Sergei Gorlatch and Marco Danelutto},
month = nov,
pages = {59-68},
publisher = {Universit{\a} di Pisa, Dipartimento di Informatica},
title = {Towards the Automatic Mapping of {ASSIST} Applications for the Grid},
volume = {TR-05-22},
year = {2005},
}

• J. Dünnweber, S. Gorlatch, S. Campa, M. Aldinucci, and M. Danelutto, “Using code parameters for component adaptations,” in Proc. of the integrated research in grid computing workshop, Pisa, Italy, 2005, pp. 49-57.

Adaptation means that the behavior of a software component is adjusted to application or platform-specific requirements: new components required in a particular application do not need to be developed from scratch when available components can be adapted accordingly. Instead of introducing a new adaptation syntax (as it is done, e. g. , in AOP), we describe adaptations in the context of Java-based Higher-Order Components (HOCs). HOCs incorporate a code parameter plugin mechanism enabling adaptations on the grid. Our approach is illustrated using a case study of sequence alignment. We show how a HOC with the required provisions for data dependencies in this application can be generated by adapting a farm component, which is “embarrassingly parallel”, i.e., free of data dependencies. This way, we could reuse the efficient farm implementation from the Lithium library, although our case study exhibits the wavefront pattern of parallelism which is different from the farm.

@inproceedings{codeadapt:IW:05,
abstract = {Adaptation means that the behavior of a software component is adjusted to application or platform-specific requirements: new components required in a particular application do not need to be developed from scratch when available components can be adapted accordingly. Instead of introducing a new adaptation syntax (as it is done, e. g. , in AOP), we describe adaptations in the context of Java-based Higher-Order Components (HOCs). HOCs incorporate a code parameter plugin mechanism enabling adaptations on the grid. Our approach is illustrated using a case study of sequence alignment. We show how a HOC with the required provisions for data dependencies in this application can be generated by adapting a farm component, which is "embarrassingly parallel", i.e., free of data dependencies. This way, we could reuse the efficient farm implementation from the Lithium library, although our case study exhibits the wavefront pattern of parallelism which is different from the farm.},
author = {Jan D{\"u}nnweber and Sergei Gorlatch and Sonia Campa and Marco Aldinucci and Marco Danelutto},
booktitle = {Proc. of the Integrated Research in Grid Computing Workshop},
date-modified = {2009-02-03 20:12:52 +0100},
editor = {Sergei Gorlatch and Marco Danelutto},
month = {nov},
owner = {aldinuc},
pages = {49-57},
publisher = {Universit{\a} di Pisa, Dipartimento di Informatica},
timestamp = {2006.06.28},
title = {Using Code Parameters for Component Adaptations},
volume = {TR-05-22},
year = {2005},
}

• M. Pasin, P. Kuonen, M. Danelutto, and M. Aldinucci, “Skeleton parallel programming and parallel objects,” in Proc. of the integrated research in grid computing workshop, Pisa, Italy, 2005, pp. 115-124.

We describe here the ongoing work aimed at integrating the POP-C++ parallel object programming environment with the ASSIST component based parallel programming environment. Both these programming environments are shortly outlined, first. Then several possibilities of integration are considered. For each one of these integration opportunities, the advantages and synergies that can be possibly achieved are outlined and discussed. Eventually, the current status of integration of the two environments is discussed, along with the expected results and fallouts on the two programming environments.

@inproceedings{pasin:IW:05,
abstract = {We describe here the ongoing work aimed at integrating the POP-C++ parallel object programming environment with the ASSIST component based parallel programming environment. Both these programming environments are shortly outlined, first. Then several possibilities of integration are considered. For each one of these integration opportunities, the advantages and synergies that can be possibly achieved are outlined and discussed. Eventually, the current status of integration of the two environments is discussed, along with the expected results and fallouts on the two programming environments.},
author = {Marcelo Pasin and Pierre Kuonen and Marco Danelutto and Marco Aldinucci},
booktitle = {Proc. of the Integrated Research in Grid Computing Workshop},
date-modified = {2009-02-03 20:28:52 +0100},
editor = {Sergei Gorlatch and Marco Danelutto},
month = nov,
owner = {aldinuc},
pages = {115-124},
publisher = {Universit{\a} di Pisa, Dipartimento di Informatica},
timestamp = {2006.06.28},
title = {Skeleton Parallel Programming and Parallel Objects},
volume = {TR-05-22},
year = {2005},
}

• M. Aldinucci, M. Vanneschi, and M. Villa, “Grid technologies and c-business for SMEs,” in Innovation and the knowledge economy: issues, applications, case studies (proc. of intl. conference echallenges 2005), Amsterdam, The Netherland, 2005.

We describe the objectives of project SFIDA, aiming at developing a Grid-based interoperable platform able to support next generation applications specifically addressing the needs of SMEs. We sketch the architecture of the platform under development in SFIDA, which will support componentization (e-services), intelligence (mining), collaboration (c-business), and customer business-processes orientation concepts on top of ASSIST, a Grid-aware high-level programming environment. The SFIDA project outcomes will be validated on Supply Chain Management applications matching various typical industrial cases, spanning from automotive, textile, food, white goods, and media retail. Finally we show what business benefits it is expected to bring.

@inproceedings{sfida:echallenges:05,
abstract = {We describe the objectives of project SFIDA, aiming at developing a Grid-based interoperable platform able to support next generation applications specifically addressing the needs of SMEs. We sketch the architecture of the platform under development in SFIDA, which will support componentization (e-services), intelligence (mining), collaboration (c-business), and customer business-processes orientation concepts on top of ASSIST, a Grid-aware high-level programming environment. The SFIDA project outcomes will be validated on Supply Chain Management applications matching various typical industrial cases, spanning from automotive, textile, food, white goods, and media retail. Finally we show what business benefits it is expected to bring.},
author = {Marco Aldinucci and Marco Vanneschi and Matteo Villa},
booktitle = {Innovation and the Knowledge Economy: Issues, Applications, Case Studies (Proc. of Intl. conference eChallenges 2005)},
date-modified = {2009-02-03 17:50:53 +0100},
editor = {P. Cunningham and M. Cunningham},
month = oct,
optnote = {ISBN: 1-58603-563-0},
publisher = {IOS press},
series = {Information and Communication Technologies and the Knowledge Economy},
title = {Grid technologies and c-business for {SME}s},
volume = {2},
year = {2005},
}

• M. Aldinucci, M. Danelutto, J. Dünnweber, and S. Gorlatch, “Optimization techniques for skeletons on grids,” in Grid computing and new frontiers of high performance processing, L. Grandinetti, Ed., Elsevier, 2005, vol. 14, pp. 255-273. doi:10.1016/S0927-5452(05)80014-0

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.

@incollection{vigoni:fut_rmi:book:05,
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.},
author = {Marco Aldinucci and Marco Danelutto and Jan D{\"u}nnweber and Sergei Gorlatch},
booktitle = {Grid Computing and New Frontiers of High Performance Processing},
chapter = {2},
date-modified = {2012-09-23 11:03:01 +0000},
doi = {10.1016/S0927-5452(05)80014-0},
editor = {L. Grandinetti},
isbn = {0-444-51999-8},
issn = {09275452},
month = oct,
pages = {255-273},
publisher = {Elsevier},
series = {Advances in Parallel Computing},
title = {Optimization techniques for skeletons on grids},
volume = {14},
year = {2005},
bdsk-url-2 = {http://dx.doi.org/10.1016/S0927-5452(05)80014-0}
}

• M. Aldinucci, A. Petrocelli, E. Pistoletti, M. Torquati, M. Vanneschi, L. Veraldi, and C. Zoccolo, “Dynamic reconfiguration of grid-aware applications in ASSIST,” in Proc. of 11th intl. euro-par 2005 parallel processing, 2005, pp. 771-781. doi:10.1007/11549468_84

Current grid-aware applications are implemented on top of low-level libraries by developers who are experts on grid middleware architecture. This approach can hardly support the additional complexity of QoS control in real applications. We discuss a novel approach used in the ASSIST programming environment to implement/guarantee user provided QoS contracts in a transparent and effective way. Our approach is based on the implementation of automatic run-time reconfiguration of ASSIST application executions triggered by mismatch between the user provided QoS contract and the actual performance values achieved.

@inproceedings{dyn:europar:05,
abstract = {Current grid-aware applications are implemented on top of low-level libraries by developers who are experts on grid middleware architecture. This approach can hardly support the additional complexity of QoS control in real applications. We discuss a novel approach used in the ASSIST programming environment to implement/guarantee user provided QoS contracts in a transparent and effective way. Our approach is based on the implementation of automatic run-time reconfiguration of ASSIST application executions triggered by mismatch between the user provided QoS contract and the actual performance values achieved.},
author = {Marco Aldinucci and Alessandro Petrocelli and Edoardo Pistoletti and Massimo Torquati and Marco Vanneschi and Luca Veraldi and Corrado Zoccolo},
booktitle = {Proc. of 11th Intl. Euro-Par 2005 Parallel Processing},
date-modified = {2009-01-23 00:16:41 +0100},
doi = {10.1007/11549468_84},
editor = {J. C. Cunha and P. D. Medeiros},
month = aug,
pages = {771-781},
publisher = {Springer},
series = {LNCS},
title = {Dynamic reconfiguration of grid-aware applications in {ASSIST}},
volume = {3648},
year = {2005},
bdsk-url-2 = {http://dx.doi.org/10.1007/11549468_84}
}

• M. Aldinucci and A. Benoit, “Automatic mapping of ASSIST applications using process algebra,” in Proc. of hlpp2005: intl. workshop on high-level parallel programming, 2005. doi:10.1142/S0129626408003302

One of the most promising technical innovations in present-day computing is the invention of grid technologies which harness the computational power of widely distributed collections of computers. However, the programming and optimisation burden of a low level approach to grid computing is clearly unacceptable for large scale, complex applications. The development of grid applications can be simplified by using high-level programming environments. In the present work, we address the problem of the mapping of a high-level grid application onto the computational resources. In order to optimise the mapping of the application, we propose to automatically generate performance models from the application using the process algebra PEPA. We target applications written with the high-level environment ASSIST, since the use of such a structured environment allows us to automate the study of the application more effectively. Our methodology is presented through an example of a classical Divide&Conquer algorithm, together with results which demonstrate the efficiency of this approach.

@inproceedings{pepa_assist:hlpp:05,
abstract = {One of the most promising technical innovations in present-day computing is the invention of grid technologies which harness the computational power of widely distributed collections of computers. However, the programming and optimisation burden of a low level approach to grid computing is clearly unacceptable for large scale, complex applications. The development of grid applications can be simplified by using high-level programming environments. In the present work, we address the problem of the mapping of a high-level grid application onto the computational resources. In order to optimise the mapping of the application, we propose to automatically generate performance models from the application using the process algebra PEPA. We target applications written with the high-level environment ASSIST, since the use of such a structured environment allows us to automate the study of the application more effectively. Our methodology is presented through an example of a classical Divide\&Conquer algorithm, together with results which demonstrate the efficiency of this approach.},
author = {Marco Aldinucci and Anne Benoit},
booktitle = {Proc. of HLPP2005: Intl. Workshop on High-Level Parallel Programming},
date-modified = {2007-09-16 18:42:58 +0200},
doi = {10.1142/S0129626408003302},
month = jul,
organization = {Warwick University, Coventry, UK},
title = {Automatic mapping of {ASSIST} applications using process algebra},
year = {2005},
bdsk-url-2 = {http://dx.doi.org/10.1142/S0129626408003302}
}

• M. Aldinucci, S. Gusmeroli, M. Vanneschi, and M. Villa, “SFIDA: interoperability in innovative c-business models for SMEs through an enabling grid platform,” in Pre-proc. of interop-esa: intl. conference on interoperability on enterprise software and applications, Geneva, Switzerland, 2005, pp. 547-557.

This position paper describes the objectives of project “SFIDA” (co-funded by the Italian Government), aiming at developing a GRID-based inter-operability platform able to support next generation Supply Chain Management applications specifically addressing the needs of SMEs belonging to industrial districts and dynamic supply networks. Next generation SCM applications are intended in SFIDA to be based on componentization (e-services), intelligence (mining), collaboration (c-business) and customer business-processes orientation. The platform and the next generation SCM applications running on top of it will be tested in various typical industrial cases, spanning from automotive, textile, food, white goods and media retail.

@inproceedings{sfida:interop:05,
abstract = {This position paper describes the objectives of project "SFIDA" (co-funded by the Italian Government), aiming at developing a GRID-based inter-operability platform able to support next generation Supply Chain Management applications specifically addressing the needs of SMEs belonging to industrial districts and dynamic supply networks. Next generation SCM applications are intended in SFIDA to be based on componentization (e-services), intelligence (mining), collaboration (c-business) and customer business-processes orientation. The platform and the next generation SCM applications running on top of it will be tested in various typical industrial cases, spanning from automotive, textile, food, white goods and media retail.},
author = {Marco Aldinucci and Sergio Gusmeroli and Marco Vanneschi and Matteo Villa},
booktitle = {Pre-proc. of INTEROP-ESA: Intl. Conference on Interoperability on Enterprise Software and Applications},
date-modified = {2007-09-16 18:43:26 +0200},
month = feb,
pages = {547-557},
title = {{SFIDA}: interoperability in innovative c-business models for {SMEs} through an enabling Grid platform},
year = {2005},
}

• M. Aldinucci, S. Campa, M. Coppola, M. Danelutto, D. Laforenza, D. Puppin, L. Scarponi, M. Vanneschi, and C. Zoccolo, “Components for high performance grid programming in grid.it,” in Proc. of the intl. workshop on component models and systems for grid applications, Saint-Malo, France, 2005, pp. 19-38. doi:10.1007/0-387-23352-0_2

This paper presents the main ideas of the high-performance component-based Grid programming environment of the Grid.it project. High-performance components are characterized by a programming model that integrates the concepts of structured parallelism, component interaction, compositionality, and adaptivity. We show that ASSIST, the prototype of parallel programming environment currently under development at our group, is a suitable basis to capture all the desired features of the component model in a flexible and efficient manner. For the sake of interoperability, ASSIST modules or programs are automatically encapsulated in standard frameworks; currently, we are experimenting Web Services and the CORBA Component Model. Grid applications, built as compositions of ASSIST components and possibly other existing (legacy) components, are supported by an innovative Grid Abstract Machine, that includes essential abstractions of standard middleware services and a hierarchical Application Manager (AM). AM supports static allocation and dynamic reallocation of adaptive applications according to a performance contract, a reconfiguration strategy, and a performance model.

@inproceedings{assist:stmalo:05,
abstract = {This paper presents the main ideas of the high-performance component-based Grid programming environment of the Grid.it project. High-performance components are characterized by a programming model that integrates the concepts of structured parallelism, component interaction, compositionality, and adaptivity. We show that ASSIST, the prototype of parallel programming environment currently under development at our group, is a suitable basis to capture all the desired features of the component model in a flexible and efficient manner. For the sake of interoperability, ASSIST modules or programs are automatically encapsulated in standard frameworks; currently, we are experimenting Web Services and the CORBA Component Model. Grid applications, built as compositions of ASSIST components and possibly other existing (legacy) components, are supported by an innovative Grid Abstract Machine, that includes essential abstractions of standard middleware services and a hierarchical Application Manager (AM). AM supports static allocation and dynamic reallocation of adaptive applications according to a performance contract, a reconfiguration strategy, and a performance model.},
author = {Marco Aldinucci and Sonia Campa and Massimo Coppola and Marco Danelutto and Domenico Laforenza and Diego Puppin and Luca Scarponi and Marco Vanneschi and Corrado Zoccolo},
booktitle = {Proc. of the Intl. Workshop on Component Models and Systems for Grid Applications},
date-modified = {2009-02-03 18:34:58 +0100},
doi = {10.1007/0-387-23352-0_2},
editor = {V. Getov and T. Kielmann},
isbn = {978-0-387-23351-2},
month = jan,
pages = {19-38},
publisher = {Springer},
series = {CoreGRID},
title = {Components for high performance Grid programming in Grid.it},
year = {2005},
bdsk-url-2 = {http://dx.doi.org/10.1007/0-387-23352-0_2}
}

### 2004

• M. Aldinucci and M. Torquati, “Accelerating apache farms through ad-HOC distributed scalable object repository,” in Proc. of 10th intl. euro-par 2004 parallel processing, 2004, pp. 596-605. doi:10.1007/978-3-540-27866-5_78

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.

@inproceedings{assist:adhoc:europar:04,
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.},
author = {Marco Aldinucci and Massimo Torquati},
booktitle = {Proc. of 10th Intl. Euro-Par 2004 Parallel Processing},
date-modified = {2012-07-13 19:06:26 +0200},
doi = {10.1007/978-3-540-27866-5_78},
editor = {Marco Danelutto and Marco Vanneschi and Domenico Laforenza},
month = aug,
pages = {596-605},
publisher = {Springer},
series = {LNCS},
title = {Accelerating apache farms through {ad-HOC} distributed scalable object repository},
volume = {3149},
year = {2004},
bdsk-url-2 = {http://dx.doi.org/10.1007/978-3-540-27866-5_78}
}

• M. Aldinucci, S. Campa, M. Coppola, S. Magini, P. Pesciullesi, L. Potiti, R. Ravazzolo, M. Torquati, and C. Zoccolo, “Targeting heterogeneous architectures in ASSIST: experimental results,” in Proc. of 10th intl. euro-par 2004 parallel processing, 2004, pp. 638-643. doi:10.1142/S0129626412400063

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.

@inproceedings{assist:hetero:europar:04,
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.},
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},
booktitle = {Proc. of 10th Intl. Euro-Par 2004 Parallel Processing},
date-modified = {2009-02-04 17:56:42 +0100},
doi = {10.1142/S0129626412400063},
editor = {Marco Danelutto and Marco Vanneschi and Domenico Laforenza},
isbn = {978-3-540-22924-7},
month = aug,
pages = {638-643},
publisher = {Springer},
series = {LNCS},
title = {Targeting heterogeneous architectures in {ASSIST}: Experimental results},
volume = {3149},
year = {2004},
bdsk-url-2 = {http://dx.doi.org/10.1142/S0129626412400063}
}

• M. Aldinucci, M. Danelutto, and J. Dünnweber, “Optimization techniques for implementing parallel skeletons in grid environments,” in Proc. of cmpp: intl. workshop on constructive methods for parallel programming, Stirling, Scotland, UK, 2004, pp. 35-47.

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.

@inproceedings{lith_rmi:cmpp:04,
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.},
author = {Marco Aldinucci and Marco Danelutto and Jan D{\"u}nnweber},
booktitle = {Proc. of CMPP: Intl. Workshop on Constructive Methods for Parallel Programming},
date-modified = {2007-09-16 18:42:29 +0200},
editor = {S. Gorlatch},
month = jul,
pages = {35-47},
publisher = {Universit{\"a}t M{\"u}nster, Germany},
title = {Optimization Techniques for Implementing Parallel Skeletons in Grid Environments},
year = {2004},
}

• M. Aldinucci, S. Campa, P. Ciullo, M. Coppola, M. Danelutto, P. Pesciullesi, R. Ravazzolo, M. Torquati, M. Vanneschi, and C. Zoccolo, “A framework for experimenting with structure parallel programming environment design,” in Parallel computing: software technology, algorithms, architectures and applications (proc. of PARCO 2003, dresden, germany), 2004, pp. 617-624. doi:10.1016/S0927-5452(04)80077-7

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.

@inproceedings{assist:parco:03,
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.},
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},
booktitle = {Parallel Computing: Software Technology, Algorithms, Architectures and Applications (Proc. of {PARCO 2003}, Dresden, Germany)},
date-modified = {2012-11-26 18:49:59 +0000},
doi = {10.1016/S0927-5452(04)80077-7},
editor = {G. R. Joubert and W. E. Nagel and F. J. Peters and W. V. Walter},
issn = {09275452},
pages = {617-624},
publisher = {Elsevier},
series = {Advances in Parallel Computing},
title = {A framework for experimenting with structure parallel programming environment design},
volume = {13},
year = {2004},
bdsk-url-2 = {http://dx.doi.org/10.1016/S0927-5452(04)80077-7}
}

• M. Aldinucci and M. Danelutto, “An operational semantics for skeletons,” in Parallel computing: software technology, algorithms, architectures and applications (proc. of PARCO 2003, dresden, germany), Germany, 2004, pp. 63-70. doi:10.1016/S0927-5452(04)80011-X

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.

@inproceedings{lith:sem:parco:03,
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.},
author = {Marco Aldinucci and Marco Danelutto},
booktitle = {Parallel Computing: Software Technology, Algorithms, Architectures and Applications (Proc. of {PARCO 2003}, Dresden, Germany)},
date-modified = {2012-07-15 14:39:27 +0000},
doi = {10.1016/S0927-5452(04)80011-X},
editor = {G. R. Joubert and W. E. Nagel and F. J. Peters and W. V. Walter},
pages = {63-70},
publisher = {Elsevier},
series = {Advances in Parallel Computing},
title = {An operational semantics for skeletons},
volume = {13},
year = {2004},
bdsk-url-2 = {http://dx.doi.org/10.1016/S0927-5452(04)80011-X}
}

### 2003

• M. Aldinucci, “Dynamic shared data in structured parallel programming frameworks,” PhD Thesis, 2003.
[BibTeX]
@phdthesis{phd:marco:2003,
author = {Marco Aldinucci},
date-modified = {2008-09-14 11:58:16 +0200},
month = dec,
school = {Computer Science Dept., University of Pisa},
title = {Dynamic shared data in structured parallel programming frameworks},
year = {2003}
}

• M. Aldinucci, “Eskimo: experimenting with skeletons in the shared address model,” Parallel processing letters, vol. 13, iss. 3, pp. 449-460, 2003. doi:10.1142/S0129626403001410

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.

@article{eskimo:PPL:03,
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.},
annote = {ISSN: 0129-6264},
author = {Marco Aldinucci},
date-modified = {2014-08-24 22:20:32 +0000},
doi = {10.1142/S0129626403001410},
issn = {0129-6264},
journal = {Parallel Processing Letters},
month = sep,
number = {3},
pages = {449-460},
title = {eskimo: experimenting with Skeletons in the Shared Address Model},
volume = {13},
year = {2003},
bdsk-url-2 = {http://dx.doi.org/10.1142/S0129626403001410}
}

• M. Aldinucci, S. Campa, P. Ciullo, M. Coppola, M. Danelutto, P. Pesciullesi, R. Ravazzolo, M. Torquati, M. Vanneschi, and C. Zoccolo, “ASSIST demo: a high level, high performance, portable, structured parallel programming environment at work,” in Proc. of 9th intl. euro-par 2003 parallel processing, Klagenfurt, Austria, 2003, pp. 1295-1300. doi:10.1007/978-3-540-45209-6_176

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.

@inproceedings{assist:demo:europar:03,
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.},
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},
booktitle = {Proc. of 9th Intl. Euro-Par 2003 Parallel Processing},
date-modified = {2012-11-10 02:24:20 +0000},
doi = {10.1007/978-3-540-45209-6_176},
editor = {H. Kosch and L. B{\"o}sz{\"o}rm{\'e}nyi and H. Hellwagner},
month = aug,
pages = {1295-1300},
publisher = {Springer},
series = {LNCS},
title = {{ASSIST} demo: a high level, high performance, portable, structured parallel programming environment at work},
volume = {2790},
year = {2003},
bdsk-url-2 = {https://doi.org/10.1007/978-3-540-45209-6_176}
}

• M. Aldinucci, S. Campa, P. Ciullo, M. Coppola, S. Magini, P. Pesciullesi, L. Potiti, R. Ravazzolo, M. Torquati, M. Vanneschi, and C. Zoccolo, “The implementation of ASSIST, an environment for parallel and distributed programming,” in Proc. of 9th intl euro-par 2003 parallel processing, Klagenfurt, Austria, 2003, pp. 712-721. doi:10.1007/b12024

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.

@inproceedings{assist:imp:europar:03,
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.},
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},
booktitle = {Proc. of 9th Intl Euro-Par 2003 Parallel Processing},
date-modified = {2010-10-24 15:29:07 +0200},
doi = {10.1007/b12024},
editor = {H. Kosch and L. B{\"o}sz{\"o}rm{\'e}nyi and H. Hellwagner},
isbn = {978-3-540-40788-1},
month = aug,
pages = {712-721},
publisher = {Springer},
series = {LNCS},
title = {The Implementation of {ASSIST}, an Environment for Parallel and Distributed Programming},
volume = {2790},
year = {2003},
bdsk-url-2 = {http://dx.doi.org/10.1007/b12024}
}

• M. Aldinucci, M. Danelutto, and P. Teti, “An advanced environment supporting structured parallel programming in Java,” Future generation computer systems, vol. 19, iss. 5, pp. 611-626, 2003. doi:10.1016/S0167-739X(02)00172-3

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.

@article{lithium:fgcs:03,
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.},
author = {Marco Aldinucci and Marco Danelutto and Paolo Teti},
date-modified = {2014-08-24 22:16:31 +0000},
doi = {10.1016/S0167-739X(02)00172-3},
journal = {Future Generation Computer Systems},
month = jul,
number = {5},
pages = {611-626},
title = {An advanced environment supporting structured parallel programming in {Java}},
volume = {19},
year = {2003},
bdsk-url-2 = {http://dx.doi.org/10.1016/S0167-739X(02)00172-3}
}

• M. Aldinucci, “Eskimo: experimenting skeletons on the shared address model,” in Proc. of hlpp2003: intl. workshop on high-level parallel programming, Paris, France, 2003, pp. 89-100.

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.

@inproceedings{eskimo:hlpp:03,
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.},
author = {Marco Aldinucci},
booktitle = {Proc. of HLPP2003: Intl. Workshop on High-Level Parallel Programming},
date-modified = {2007-09-16 18:41:29 +0200},
month = jun,
pages = {89-100},
title = {eskimo: experimenting skeletons on the shared address model},
year = {2003},
}

### 2002

• M. Aldinucci, “Automatic program transformation: the Meta tool for skeleton-based languages,” in Constructive methods for parallel programming, S. Gorlatch and C. Lengauer, Eds., NY, USA: Nova science publishers, 2002, pp. 59-78.

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.

@incollection{meta:CMPP:book:02,
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.},
author = {Marco Aldinucci},
booktitle = {Constructive Methods for Parallel Programming},
chapter = {5},
date-modified = {2009-01-30 14:55:28 +0100},
editor = {Sergei Gorlatch and Christian Lengauer},
isbn = {1-59033-374-8},
pages = {59-78},
publisher = {Nova Science Publishers},
series = {Advances in Computation: Theory and Practice},
title = {Automatic Program Transformation: The {Meta} Tool for Skeleton-based Languages},
year = {2002},
}

### 2001

• M. Aldinucci, S. Gorlatch, C. Lengauer, and S. Pelagatti, “Towards parallel programming by transformation: the FAN skeleton framework,” Parallel algorithms and applications, vol. 16, iss. 2-3, pp. 87-121, 2001. doi:10.1080/01495730108935268

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.

@article{FAN:PPA:01,
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.},
author = {Marco Aldinucci and Sergei Gorlatch and Christian Lengauer and Susanna Pelagatti},
date-modified = {2014-08-24 22:19:37 +0000},
doi = {10.1080/01495730108935268},
journal = {Parallel Algorithms and Applications},
month = mar,
number = {2-3},
pages = {87-121},
title = {Towards Parallel Programming by Transformation: The {FAN} Skeleton Framework},
volume = {16},
year = {2001},
bdsk-url-2 = {http://dx.doi.org/10.1080/01495730108935268}
}

### 2000

• M. Aldinucci, “The Meta transformation tool for skeleton-based languages,” in Proc. of cmpp: intl. workshop on constructive methods for parallel programming, 2000, pp. 53-68.

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.

@inproceedings{aldinuc:meta:00,
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.},
author = {Marco Aldinucci},
booktitle = {Proc. of CMPP: Intl. Workshop on Constructive Methods for Parallel Programming},
date-modified = {2007-09-16 18:41:04 +0200},
editor = {S. Gorlatch and C. Lengauer},
month = jul,
organization = {Fakult{\"a}t f{\"u}r mathematik und informatik},
pages = {53-68},
publisher = {Uni. Passau, Germany},
title = {The {Meta} Transformation Tool for Skeleton-Based Languages},
year = {2000},
}

### 1999

• M. Aldinucci and M. Danelutto, “Stream parallel skeleton optimization,” in Proc. of pdcs: intl. conference on parallel and distributed computing and systems, Cambridge, Massachusetts, USA, 1999, pp. 955-962.

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.

@inproceedings{pdcs:nf:99,
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.},
author = {Marco Aldinucci and Marco Danelutto},
booktitle = {Proc. of PDCS: Intl. Conference on Parallel and Distributed Computing and Systems},
date-modified = {2007-09-16 18:40:51 +0200},
month = nov,
organization = {IASTED},
pages = {955-962},
publisher = {ACTA press},
title = {Stream parallel skeleton optimization},
year = {1999},
}

### 1998

• M. Aldinucci, M. Coppola, and M. Danelutto, “Rewriting skeleton programs: how to evaluate the data-parallel stream-parallel tradeoff,” in Proc. of cmpp: intl. workshop on constructive methods for parallel programming, 1998, pp. 44-58.

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.

@inproceedings{aldinuc:stream-data:98,
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.},
author = {Marco Aldinucci and Massimo Coppola and Marco Danelutto},
booktitle = {Proc. of CMPP: Intl. Workshop on Constructive Methods for Parallel Programming},
date-modified = {2007-09-16 18:40:40 +0200},
editor = {S. Gorlatch},
month = may,
optnumber = {MIP-9805},
optseries = {University of Passau technical report},
organization = {Fakult{\"a}t f{\"u}r mathematik und informatik},
pages = {44-58},
publisher = {Uni. Passau, Germany},
title = {Rewriting skeleton programs: How to evaluate the data-parallel stream-parallel tradeoff},
year = {1998},
}`