@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}

}