Papers | Parallel Computing

@inproceedings{17:hlpp:powerstream,

title = {Towards Power-Aware Data Pipelining on Multicores},

author = {Marco Aldinucci and Marco Danelutto and Daniele De Sensi and Gabriele Mencagli and Massimo Torquati},

url = {https://iris.unito.it/retrieve/handle/2318/1644982/351415/17_HLPP_powerstream.pdf},

year  = {2017},

date = {2017-01-01},

booktitle = {Proceedings of the 10th International Symposium on High-Level Parallel Programming and Applications},

address = {Valladolid, Spain},

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.},

keywords = {fastflow, rephrase},

pubstate = {published},

tppubtype = {inproceedings}

}

@inproceedings{skedato:pdp:16,

title = {A Cluster-As-Accelerator approach for SPMD-free Data Parallelism},

author = {Maurizio Drocco and Claudia Misale and Marco Aldinucci},

url = {https://iris.unito.it/retrieve/handle/2318/1611858/262689/2016_pdp_skedato.pdf},

doi = {10.1109/PDP.2016.97},

year  = {2016},

date = {2016-01-01},

booktitle = {Proc. of 24th Euromicro Intl. Conference on Parallel Distributed and network-based Processing (PDP)},

pages = {350–353},

publisher = {IEEE},

address = {Crete, Greece},

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.},

keywords = {fastflow, rephrase},

pubstate = {published},

tppubtype = {inproceedings}

}

@inproceedings{rpl:pdp:16,

title = {RPL: A Domain-Specific Language for Designing and Implementing Parallel C++ Applications},

author = {Vladimir Janjic and Christopher Brown and Kenneth MacKenzie and Kevin Hammond and Marco Danelutto and Marco Aldinucci and Jose Daniel Garcia},

url = {https://iris.unito.it/retrieve/handle/2318/1597172/299237/2016_jsupe_stencil_pp_4aperto.pdf},

doi = {10.1109/PDP.2016.122},

year  = {2016},

date = {2016-01-01},

booktitle = {Proc. of Intl. Euromicro PDP 2016: Parallel Distributed and network-based Processing},

publisher = {IEEE},

address = {Crete, Greece},

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

keywords = {fastflow, rephrase},

pubstate = {published},

tppubtype = {inproceedings}

}

@inproceedings{16:scalcom:cloud,

title = {A cloud solution for multi-omics data integration},

author = {Fabio Tordini},

url = {http://calvados.di.unipi.it/storage/paper_files/2016_cloudpipeline_scalcom.pdf},

doi = {10.1109/UIC-ATC-ScalCom-CBDCom-IoP-SmartWorld.2016.131},

year  = {2016},

date = {2016-01-01},

booktitle = {Proceedings of the 16th IEEE International Conference on Scalable Computing and Communication},

pages = {559–566},

publisher = {IEEE Computer Society},

abstract = {Recent advances in molecular biology and Bioinformatics techniques have brought to an explosion of the information about the spatial organisation of the DNA inside the nucleus. In particular, 3C-based techniques are revealing the genome folding for many different cell types, and permit to create a more effective representation of the disposition of genes in the three-dimensional space. This information can be used to re-interpret heterogeneous genomic data (multi-omic) relying on 3D maps of the chromosome. The storage and computational requirements needed to accomplish such operations on raw sequenced data have to be fulfilled using HPC solutions, and the the Cloud paradigm is a valuable and convenient mean for delivering HPC to Bioinformatics. In this work we describe a data analysis work-flow that allows the integration and the interpretation of multi-omic data on a sort of ``topographical'' nuclear map, capable of representing the effective disposition of genes in a graph-based representation. We propose a cloud-based task farm pattern to orchestrate the services needed to accomplish genomic data analysis, where each service represents a special-purpose tool, playing a part in well known data analysis pipelines.},

note = {Best paper award},

keywords = {bioinformatics, fastflow, rephrase},

pubstate = {published},

tppubtype = {inproceedings}

}

@inproceedings{16:PMAM:SPSC,

title = {Embedding Semantics of the Single-Producer/Single-Consumer Lock-Free Queue into a Race Detection Tool},

author = {Manuel F. Dolz and David Rio Astorga and Javier Fernández and J. Daniel Garc'ıa and Félix Garc'ıa-Carballeira and Marco Danelutto and Massimo Torquati},

url = {https://doi.acm.org/10.1145/2883404.2883406},

doi = {10.1145/2883404.2883406},

isbn = {978-1-4503-4196-7},

year  = {2016},

date = {2016-01-01},

booktitle = {Proceedings of the 7th International Workshop on Programming Models and Applications for Multicores and Manycores},

pages = {20–29},

publisher = {ACM},

address = {Barcelona, Spain},

series = {PMAM'16},

keywords = {fastflow, repara},

pubstate = {published},

tppubtype = {inproceedings}

}

@inproceedings{opencl:ff:ispa:15,

title = {The Loop-of-Stencil-Reduce paradigm},

author = {Marco Aldinucci and Marco Danelutto and Maurizio Drocco and Peter Kilpatrick and Guilherme Peretti Pezzi and Massimo Torquati},

url = {https://iris.unito.it/retrieve/handle/2318/1523738/52857/15_RePara_ISPA.pdf},

doi = {10.1109/Trustcom.2015.628},

year  = {2015},

date = {2015-08-01},

booktitle = {Proc. of Intl. Workshop on Reengineering for Parallelism in Heterogeneous Parallel Platforms (RePara)},

pages = {172–177},

publisher = {IEEE},

address = {Helsinki, Finland},

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.},

keywords = {fastflow, HPC, repara},

pubstate = {published},

tppubtype = {inproceedings}

}

@inproceedings{14:ff:nuchart:cibb,

title = {NuChart-II: a graph-based approach for the analysis and interpretation of Hi-C data},

author = {Fabio Tordini and Maurizio Drocco and Ivan Merelli and Luciano Milanesi and Pietro Liò and Marco Aldinucci},

editor = {Clelia Di Serio and Pietro Liò and Alessandro Nonis and Roberto Tagliaferri},

url = {http://calvados.di.unipi.it/storage/paper_files/2014_nuchart_cibb.pdf},

doi = {10.1007/978-3-319-24462-4_25},

isbn = {978-3-319-24461-7},

year  = {2015},

date = {2015-06-01},

booktitle = {Proc. of 11th Intl. Meeting on Computational Intelligence Methods for Bioinformatics and Biostatistics (CIBB)},

volume = {8623},

pages = {298–311},

publisher = {Springer},

address = {Cambridge, UK},

series = {LNCS},

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.},

keywords = {bioinformatics, fastflow, paraphrase, repara},

pubstate = {published},

tppubtype = {inproceedings}

}

@inproceedings{nuchart:speedup:15,

title = {Memory-Optimised Parallel Processing of Hi-C Data},

author = {Maurizio Drocco and Claudia Misale and Guilherme Peretti Pezzi and Fabio Tordini and Marco Aldinucci},

url = {https://iris.unito.it/retrieve/handle/2318/1521910/40615/2015_pdp_memopt.pdf},

doi = {10.1109/PDP.2015.63},

year  = {2015},

date = {2015-03-01},

booktitle = {Proc. of 23rd Euromicro Intl. Conference on Parallel Distributed and network-based Processing (PDP)},

pages = {1–8},

publisher = {IEEE},

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.},

keywords = {bioinformatics, fastflow, impact, paraphrase, repara},

pubstate = {published},

tppubtype = {inproceedings}

}

@inproceedings{nuchar:tool:15,

title = {Parallel Exploration of the Nuclear Chromosome Conformation with NuChart-II},

author = {Fabio Tordini and Maurizio Drocco and Claudia Misale and Luciano Milanesi and Pietro Liò and Ivan Merelli and Marco Aldinucci},

url = {https://iris.unito.it/retrieve/handle/2318/1522038/40619/2015_pdp_nuchartff.pdf},

doi = {10.1109/PDP.2015.104},

year  = {2015},

date = {2015-03-01},

booktitle = {Proc. of 23rd Euromicro Intl. Conference on Parallel Distributed and network-based Processing (PDP)},

publisher = {IEEE},

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.},

keywords = {bioinformatics, fastflow, impact, paraphrase, repara},

pubstate = {published},

tppubtype = {inproceedings}

}

@inproceedings{14:ff:whatsapp:cibb,

title = {High-Performance Haplotype Assembly},

author = {Marco Aldinucci and Andrea Bracciali and Tobias Marschall and Murray Patterson and Nadia Pisanti and Massimo Torquati},

editor = {Clelia Di Serio and Pietro Liò and Alessandro Nonis and Roberto Tagliaferri},

url = {https://iris.unito.it/retrieve/handle/2318/1523292/46714/2014_pHaplo_cibb.pdf},

doi = {10.1007/978-3-319-24462-4_21},

year  = {2015},

date = {2015-01-01},

booktitle = {Computational Intelligence Methods for Bioinformatics and Biostatistics - 11th International Meeting, CIBB 2014, Cambridge, UK, June 26-28, 2014, Revised Selected Papers},

volume = {8623},

pages = {245–258},

publisher = {Springer},

address = {Cambridge, UK},

series = {LNCS},

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.},

keywords = {bioinformatics, fastflow},

pubstate = {published},

tppubtype = {inproceedings}

}

@inproceedings{2014:ff:pool:hlpp,

title = {Pool evolution: a domain specific parallel pattern},

author = {Marco Aldinucci and Sonia Campa and Marco Danelutto and Peter Kilpatrick and Massimo Torquati},

url = {http://calvados.di.unipi.it/storage/paper_files/2014_hlpp_pool.pdf},

year  = {2014},

date = {2014-07-01},

booktitle = {Proc.of the 7th Intl. Symposium on High-level Parallel Programming and Applications (HLPP)},

address = {Amsterdam, The Netherlands},

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.},

keywords = {fastflow, paraphrase, repara},

pubstate = {published},

tppubtype = {inproceedings}

}

@inproceedings{ff:gtc:2014,

title = {FastFlow: Combining Pattern-Level Abstraction and Efficiency in GPGPUs},

author = {Marco Aldinucci and Massimo Torquati and Maurizio Drocco and Guilherme Peretti Pezzi and Concetto Spampinato},

url = {http://calvados.di.unipi.it/storage/talks/2014_S4729-Marco-Aldinucci.pdf},

year  = {2014},

date = {2014-03-01},

booktitle = {GPU Technology Conference (GTC)},

address = {San Jose, CA, USA},

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.},

keywords = {fastflow, HPC, impact, paraphrase},

pubstate = {published},

tppubtype = {inproceedings}

}

@inproceedings{ff:gtc:2014:short,

title = {An Overview of FastFlow: Combining Pattern-Level Abstraction and Efficiency in GPGPUs},

author = {Marco Aldinucci and Massimo Torquati and Maurizio Drocco and Guilherme Peretti Pezzi and Concetto Spampinato},

url = {http://calvados.di.unipi.it/storage/talks/2014_S4585-Marco-Aldinucci.pdf},

year  = {2014},

date = {2014-03-01},

booktitle = {GPU Technology Conference (GTC)},

address = {San Jose, CA, USA},

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.},

keywords = {fastflow, HPC, impact, paraphrase},

pubstate = {published},

tppubtype = {inproceedings}

}

@inproceedings{ff:ffmdf:pdcn:14,

title = {A Lightweight Run-Time Support For Fast Dense Linear Algebra on Multi-Core},

author = {Daniele Buono and Marco Danelutto and Tiziano De Matteis and Gabriele Mencagli and Massimo Torquati},

year  = {2014},

date = {2014-02-01},

booktitle = {Proc. of the 12th International Conference on Parallel and Distributed Computing and Networks (PDCN 2014)},

publisher = {IASTED, ACTA press},

keywords = {fastflow},

pubstate = {published},

tppubtype = {inproceedings}

}

@inproceedings{cwc:gpu:dcperf:14,

title = {Exercising high-level parallel programming on streams: a systems biology use case},

author = {Marco Aldinucci and Maurizio Drocco and Guilherme Peretti Pezzi and Claudia Misale and Fabio Tordini and Massimo Torquati},

url = {https://iris.unito.it/retrieve/handle/2318/154516/26657/2014_dcperf_cwc_gpu.pdf},

doi = {10.1109/ICDCSW.2014.38},

year  = {2014},

date = {2014-01-01},

booktitle = {Proc. of 34th IEEE Intl. Conference on Distributed Computing Systems Workshops (ICDCSW)},

publisher = {IEEE},

address = {Madrid, Spain},

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.},

keywords = {bioinformatics, fastflow, impact, paraphrase},

pubstate = {published},

tppubtype = {inproceedings}

}

@inproceedings{ff:video:hlpgpu:14,

title = {Parallel video denoising on heterogeneous platforms},

author = {Marco Aldinucci and Guilherme Peretti Pezzi and Maurizio Drocco and Fabio Tordini and Peter Kilpatrick and Massimo Torquati},

url = {http://calvados.di.unipi.it/storage/paper_files/2014_ff_video_denoiser_hlpgpu.pdf},

year  = {2014},

date = {2014-01-01},

booktitle = {Proc. of Intl. Workshop on High-level Programming for Heterogeneous and Hierarchical Parallel Systems (HLPGPU)},

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.},

keywords = {fastflow, impact, paraphrase},

pubstate = {published},

tppubtype = {inproceedings}

}

@inproceedings{ff:bowtie2:pdp:14,

title = {Accelerating Bowtie2 with a lock-less concurrency approach and memory affinity},

author = {Claudia Misale},

editor = {Marco Aldinucci and Daniele D'Agostino and Peter Kilpatrick},

url = {http://calvados.di.unipi.it/storage/paper_files/2014_pdp_bowtieff.pdf},

doi = {10.1109/PDP.2014.50},

year  = {2014},

date = {2014-01-01},

booktitle = {Proc. of Intl. Euromicro PDP 2014: Parallel Distributed and network-based Processing},

publisher = {IEEE},

address = {Torino, Italy},

abstract = {The implementation of DNA alignment tools for Bioinformatics lead to face different problems that dip into performances. A single alignment takes an amount of time that is not predictable and there are different factors that can affect performances, for instance the length of sequences can determine the computational grain of the task and mismatches or insertion/deletion (indels) increase time needed to complete an alignment. Moreover, an alignment is a strong memory- bound problem because of the irregular memory access pat- terns and limitations in memory-bandwidth. Over the years, many alignment tools were implemented. A concrete example is Bowtie2, one of the fastest (concurrent, Pthread-based) and state of the art not GPU-based alignment tool. Bowtie2 exploits concurrency by instantiating a pool of threads, which have access to a global input dataset, share the reference genome and have access to different objects for collecting alignment results. In this paper a modified implementation of Bowtie2 is presented, in which the concurrency structure has been changed. The proposed implementation exploits the task-farm skeleton pattern implemented as a Master-Worker. The Master-Worker pattern permits to delegate only to the Master thread dataset reading and to make private to each Worker data structures that are shared in the original version. Only the reference genome is left shared. As a further optimisation, the Master and each Worker were pinned on cores and the reference genome was allocated interleaved among memory nodes. The proposed implementation is able to gain up to 10 speedup points over the original implementation.},

note = {(Best paper award)},

keywords = {fastflow, paraphrase},

pubstate = {published},

tppubtype = {inproceedings}

}

@inproceedings{ff:infiniband:pdp:14,

title = {Message passing on InfiniBand RDMA for parallel run-time supports},

author = {Alessandro Secco and Irfan Uddin and Guilherme Peretti Pezzi and Massimo Torquati},

editor = {Marco Aldinucci and Daniele D'Agostino and Peter Kilpatrick},

url = {https://iris.unito.it/retrieve/handle/2318/151178/690885/2014_ff_infiniband_pdp.pdf},

doi = {10.1109/PDP.2014.23},

year  = {2014},

date = {2014-01-01},

booktitle = {Proc. of Intl. Euromicro PDP 2014: Parallel Distributed and network-based Processing},

publisher = {IEEE},

address = {Torino, Italy},

abstract = {InfiniBand networks are commonly used in the high performance computing area. They offer RDMA-based opera- tions that help to improve the performance of communication subsystems. In this paper, we propose a minimal message-passing communication layer providing the programmer with a point-to- point communication channel implemented by way of InfiniBand RDMA features. Differently from other libraries exploiting the InfiniBand features, such as the well-known Message Passing Interface (MPI), the proposed library is a communication layer only rather than a programming model, and can be easily used as building block for high-level parallel programming frameworks. Evaluated on micro-benchmarks, the proposed RDMA-based communication channel implementation achieves a comparable performance with highly optimised MPI/InfiniBand implemen- tations. Eventually, the flexibility of the communication layer is evaluated by integrating it within the FastFlow parallel frame- work, currently supporting TCP/IP networks (via the ZeroMQ communication library).},

keywords = {fastflow, impact, paraphrase},

pubstate = {published},

tppubtype = {inproceedings}

}

@inproceedings{ff:acaces:14,

title = {A Dynamic Memory Allocator for heterogeneous platforms},

author = {Maurizio Drocco and Marco Aldinucci and Massimo Torquati},

url = {http://calvados.di.unipi.it/storage/paper_files/2014_ACACES_ex-abstract.pdf},

year  = {2014},

date = {2014-01-01},

booktitle = {Advanced Computer Architecture and Compilation for High-Performance and Embedded Systems (ACACES) – Poster Abstracts},

publisher = {HiPEAC},

address = {Fiuggi, Italy},

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.},

keywords = {fastflow, HPC},

pubstate = {published},

tppubtype = {inproceedings}

}

@inproceedings{ff_cwc_distr:pdp:13,

title = {Parallel stochastic simulators in system biology: the evolution of the species},

author = {Marco Aldinucci and Fabio Tordini and Maurizio Drocco and Massimo Torquati and Mario Coppo},

url = {http://calvados.di.unipi.it/storage/paper_files/2013_cwc_d_PDP.pdf},

doi = {10.1109/PDP.2013.66},

year  = {2013},

date = {2013-02-01},

booktitle = {Proc. of 21st Euromicro Intl. Conference on Parallel Distributed and network-based Processing (PDP)},

publisher = {IEEE},

address = {Belfast, Nothern Ireland, U.K.},

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.},

keywords = {bioinformatics, fastflow},

pubstate = {published},

tppubtype = {inproceedings}

}

@inproceedings{ff:acaces:13,

title = {Memory affinity in multi-threading: the Bowtie2 case study},

author = {Claudia Misale and Marco Aldinucci and Massimo Torquati},

url = {https://iris.unito.it/retrieve/handle/2318/143005/23874/2013_ACACES_ex-abstract.pdf},

isbn = {9789038221908},

year  = {2013},

date = {2013-01-01},

booktitle = {Advanced Computer Architecture and Compilation for High-Performance and Embedded Systems (ACACES) – Poster Abstracts},

publisher = {HiPEAC},

address = {Fiuggi, Italy},

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.},

keywords = {fastflow},

pubstate = {published},

tppubtype = {inproceedings}

}

@inproceedings{annotation:para:12,

title = {Structured Data Access Annotations for Massively Parallel Computations},

author = {Marco Aldinucci and Sonia Campa and Peter Kilpatrick and Massimo Torquati},

url = {http://calvados.di.unipi.it/storage/paper_files/2013_annot_europar_workshops.pdf},

doi = {10.1007/978-3-642-36949-0_42},

year  = {2013},

date = {2013-01-01},

booktitle = {Euro-Par 2012 Workshops, Proc. of the ParaPhrase Workshop on Parallel Processing},

volume = {7640},

pages = {381–390},

publisher = {Springer},

series = {LNCS},

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.},

keywords = {fastflow, paraphrase},

pubstate = {published},

tppubtype = {inproceedings}

}

@inproceedings{ff:distr:cgs:12,

title = {Targeting Distributed Systems in FastFlow},

author = {Marco Aldinucci and Sonia Campa and Marco Danelutto and Peter Kilpatrick and Massimo Torquati},

url = {http://calvados.di.unipi.it/storage/paper_files/2012_distr_ff_cgsymph.pdf},

doi = {10.1007/978-3-642-36949-0_7},

year  = {2013},

date = {2013-01-01},

booktitle = {Euro-Par 2012 Workshops, Proc. of the CoreGrid Workshop on Grids, Clouds and P2P Computing},

volume = {7640},

pages = {47–56},

publisher = {Springer},

series = {LNCS},

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.},

keywords = {fastflow, paraphrase},

pubstate = {published},

tppubtype = {inproceedings}

}

@inproceedings{denoiser:ff:ipta:12,

title = {A Parallel Edge Preserving Algorithm for Salt and Pepper Image Denoising},

author = {Marco Aldinucci and Concetto Spampinato and Maurizio Drocco and Massimo Torquati and Simone Palazzo},

editor = {K. Djemal and M. Deriche and W. Puech and Osman N. Ucan},

url = {http://calvados.di.unipi.it/storage/paper_files/2012_2phasedenoiser_ff_ipta.pdf},

doi = {10.1109/IPTA.2012.6469567},

isbn = {978-1-4673-2582-0},

year  = {2012},

date = {2012-10-01},

booktitle = {Proc. of 2nd Intl. Conference on Image Processing Theory Tools and Applications (IPTA)},

pages = {97–102},

publisher = {IEEE},

address = {Istambul, Turkey},

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.},

keywords = {fastflow, impact},

pubstate = {published},

tppubtype = {inproceedings}

}

@inproceedings{ff:spsc:europar:12,

title = {An Efficient Unbounded Lock-Free Queue for Multi-core Systems},

author = {Marco Aldinucci and Marco Danelutto and Peter Kilpatrick and Massimiliano Meneghin and Massimo Torquati},

url = {http://calvados.di.unipi.it/storage/paper_files/2012_spsc_europar.pdf},

doi = {10.1007/978-3-642-32820-6_65},

year  = {2012},

date = {2012-08-01},

booktitle = {Proc. of 18th Intl. Euro-Par 2012 Parallel Processing},

volume = {7484},

pages = {662–673},

publisher = {Springer},

address = {Rhodes Island, Greece},

series = {LNCS},

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.},

keywords = {fastflow, paraphrase},

pubstate = {published},

tppubtype = {inproceedings}

}

@inproceedings{dataflow:pdp:12,

title = {Parallel patterns + Macro Data Flow for multi-core programming},

author = {Marco Aldinucci and Marco Danelutto and Lorenzo Anardu and Massimo Torquati and Peter Kilpatrick},

url = {http://calvados.di.unipi.it/storage/paper_files/2012_mdf_PDP.pdf},

doi = {10.1109/PDP.2012.44},

year  = {2012},

date = {2012-02-01},

booktitle = {Proc. of Intl. Euromicro PDP 2012: Parallel Distributed and network-based Processing},

pages = {27–36},

publisher = {IEEE},

address = {Garching, Germany},

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.},

keywords = {fastflow},

pubstate = {published},

tppubtype = {inproceedings}

}

@inproceedings{cwcsim:onlinestats:ff:hibb:11,

title = {On Parallelizing On-Line Statistics for Stochastic Biological Simulations},

author = {Marco Aldinucci and Mario Coppo and Ferruccio Damiani and Maurizio Drocco and Eva Sciacca and Salvatore Spinella and Massimo Torquati and Angelo Troina},

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äff and Geoffroy Vallée and Josef Weidendorfer},

url = {http://calvados.di.unipi.it/storage/paper_files/2012_onlinestat_HiBB2011.pdf},

doi = {10.1007/978-3-642-29740-3_2},

year  = {2012},

date = {2012-01-01},

booktitle = {Proc. of Euro-Par Workshops: 2nd Workshop on High Performance Bioinformatics and Biomedicine (HiBB)},

volume = {7156},

pages = {3–12},

publisher = {Springer},

address = {Bordeaux, France},

series = {LNCS},

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.},

keywords = {bioinformatics, fastflow},

pubstate = {published},

tppubtype = {inproceedings}

}

@inproceedings{ff:acaces:12,

title = {High-level lock-less programming for multicore},

author = {Fabio Tordini and Marco Aldinucci and Massimo Torquati},

url = {http://calvados.di.unipi.it/storage/paper_files/2012_ACACES_ex-abstract.pdf},

isbn = {9789038219875},

year  = {2012},

date = {2012-01-01},

booktitle = {Advanced Computer Architecture and Compilation for High-Performance and Embedded Systems (ACACES) – Poster Abstracts},

publisher = {HiPEAC},

address = {Fiuggi, Italy},

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.},

keywords = {fastflow},

pubstate = {published},

tppubtype = {inproceedings}

}

@inproceedings{ff:acc:europar:11,

title = {Accelerating code on multi-cores with FastFlow},

author = {Marco Aldinucci and Marco Danelutto and Peter Kilpatrick and Massimiliano Meneghin and Massimo Torquati},

editor = {E. Jeannot and R. Namyst and J. Roman},

url = {http://calvados.di.unipi.it/storage/paper_files/2011_fastflow_acc_europar.pdf},

doi = {10.1007/978-3-642-23397-5_17},

year  = {2011},

date = {2011-08-01},

booktitle = {Proc. of 17th Intl. Euro-Par 2011 Parallel Processing},

volume = {6853},

pages = {170–181},

publisher = {Springer},

address = {Bordeaux, France},

series = {LNCS},

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.},

keywords = {fastflow},

pubstate = {published},

tppubtype = {inproceedings}

}

@inproceedings{ff:cwc:pdp:11,

title = {On Designing Multicore-Aware Simulators for Biological Systems},

author = {Marco Aldinucci and Mario Coppo and Ferruccio Damiani and Maurizio Drocco and Massimo Torquati and Angelo Troina},

editor = {Yiannis Cotronis and Marco Danelutto and George Angelos Papadopoulos},

url = {http://calvados.di.unipi.it/storage/paper_files/2011_ff_cwc_sim_PDP.pdf},

doi = {10.1109/PDP.2011.81},

year  = {2011},

date = {2011-02-01},

booktitle = {Proc. of 19th Euromicro Intl. Conference on Parallel Distributed and network-based Processing (PDP)},

pages = {318–325},

publisher = {IEEE},

address = {Ayia Napa, Cyprus},

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.},

keywords = {fastflow},

pubstate = {published},

tppubtype = {inproceedings}

}

@inproceedings{fastflow_c45:emclpkdd,

title = {Porting Decision Tree Algorithms to Multicore using FastFlow},

author = {Marco Aldinucci and Salvatore Ruggieri and Massimo Torquati},

editor = {José L. Balcázar and Francesco Bonchi and Aristides Gionis and Michèle Sebag},

url = {http://calvados.di.unipi.it/storage/paper_files/2010_c45FF_ECMLPKDD.pdf},

doi = {10.1007/978-3-642-15880-3_7},

year  = {2010},

date = {2010-09-01},

booktitle = {Proc. of European Conference in Machine Learning and Knowledge Discovery in Databases (ECML PKDD)},

volume = {6321},

pages = {7–23},

publisher = {Springer},

address = {Barcelona, Spain},

series = {LNCS},

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.},

keywords = {fastflow},

pubstate = {published},

tppubtype = {inproceedings}

}

@inproceedings{fastflow:pdp:10,

title = {Efficient Smith-Waterman on multi-core with FastFlow},

author = {Marco Aldinucci and Massimiliano Meneghin and Massimo Torquati},

editor = {Marco Danelutto and Tom Gross and Julien Bourgeois},

url = {http://calvados.di.unipi.it/storage/paper_files/2010_fastflow_SW_PDP.pdf},

doi = {10.1109/PDP.2010.93},

year  = {2010},

date = {2010-02-01},

booktitle = {Proc. of Intl. Euromicro PDP 2010: Parallel Distributed and network-based Processing},

pages = {195–199},

publisher = {IEEE},

address = {Pisa, Italy},

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.},

keywords = {fastflow},

pubstate = {published},

tppubtype = {inproceedings}

}