Maurizio Drocco

Postdoctoral Researcher
Computer Science Department, University of Turin
Parallel Computing group
Via Pessinetto 12, 10149 Torino – Italy icona mappa
E-mail: drocco AT di.unito.it
skype Linkedin

Summary

Maurizio Drocco is a Postdoctoral Researcher at University of Torino. He received his Ph.D. in Computer Science from the University of Torino in October 2017, with a thesis about distributed programming in C++.

He has been Research Intern at the IBM TJ Watson Research Center (NY) in 2015, working on parallel graph processing (Graph500), and at the IBM Dublin Research Lab in 2013, working on semi-automatic tuning of parallel applications. He is research associate at University of Torino since 2009. He has co-authored papers in international journals and conference proceedings (Google Scholar h-index 8).

His research focuses on high-level parallel programming for high-performance computing, in particular models and methods for heterogeneous platforms.

[cv (last update: 2017 December)]

Publications

2017

  • M. Drocco, “Parallel Programming with Global Asynchronous Memory: Models, C++ APIs and Implementations,” PhD Thesis, 2017. doi:10.5281/zenodo.1037585
    [BibTeX] [Abstract] [Download PDF]

    In the realm of High Performance Computing (HPC), message passing has been the programming paradigm of choice for over twenty years. The durable MPI (Message Passing Interface) standard, with send/receive communication, broadcast, gather/scatter, and reduction collectives is still used to construct parallel programs where each communication is orchestrated by the de\-vel\-oper-based precise knowledge of data distribution and overheads; collective communications simplify the orchestration but might induce excessive synchronization. Early attempts to bring shared-memory programming model—with its programming adv\-antages—to distributed computing, referred as the Distributed Shared Memory (DSM) model, faded away; one of the main issue was to combine performance and programmability with the memory consistency model. The recently proposed Partitioned Global Address Space (PGAS) model is a modern revamp of DSM that exposes data placement to enable optimizations based on locality, but it still addresses (simple) data-parallelism only and it relies on expensive sharing protocols. We advocate an alternative programming model for distributed computing based on a Global Asynchronous Memory (GAM), aiming to \emphavoid coherency and consistency problems rather than solving them. We materialize GAM by designing and implementing a \emphdistributed smart pointers library, inspired by C++ smart pointers. In this model, public and private pointers (resembling C++ shared and unique pointers, respectively) are moved around instead of messages (i.e., data), thus alleviating the user from the burden of minimizing transfers. On top of smart pointers, we propose a high-level C++ template library for writing applications in terms of dataflow-like networks, namely GAM nets, consisting of stateful processors exchanging pointers in fully asynchronous fashion. We demonstrate the validity of the proposed approach, from the expressiveness perspective, by showing how GAM nets can be exploited to implement higher-level parallel programming models, such as data and task parallelism. As for the performance perspective, the execution of two non-toy benchmarks on a number of different small-scale HPC clusters exhibits both close-to-ideal scalability and negligible overhead with respect to state-of-the-art benchmark implementations. For instance, the GAM implementation of a high-quality video restoration filter sustains a 100 fps throughput over 70\%-noisy high-quality video streams on a 4-node cluster of Graphics Processing Units (GPUs), with minimal programming effort.

    @phdthesis{17:gam:drocco:thesis,
      abstract = {In the realm of High Performance Computing (HPC), message passing 
    has been the programming paradigm of choice for over twenty years.
    The durable MPI (Message Passing Interface) standard, with send/receive 
    communication,
    broadcast, gather/scatter, and reduction collectives is still used to construct 
    parallel programs where each communication is orchestrated by the 
    de\-vel\-oper-based precise knowledge of data distribution and overheads; 
    collective communications simplify the orchestration but might induce excessive 
    synchronization.
    Early attempts to bring shared-memory programming model---with its programming 
    adv\-antages---to distributed computing, referred as the Distributed Shared 
    Memory (DSM) model, faded away; one of the main issue was to combine 
    performance and programmability with the memory consistency model.
    The recently proposed Partitioned Global Address Space (PGAS) model is a modern 
    revamp of DSM that exposes data placement to enable optimizations based on 
    locality, but it still addresses (simple) data-parallelism only and it relies 
    on expensive sharing protocols.
    We advocate an alternative programming model for distributed computing based on 
    a Global Asynchronous Memory (GAM), aiming to \emph{avoid} coherency and 
    consistency problems rather than solving them.
    We materialize GAM by designing and implementing a \emph{distributed smart 
    pointers} library, inspired by C++ smart pointers.
    In this model, public and private pointers (resembling C++ shared and unique 
    pointers, respectively) are moved around instead of messages (i.e., data), thus 
    alleviating the user from the burden of minimizing transfers.
    On top of smart pointers, we propose a high-level C++ template library for 
    writing applications in terms of dataflow-like networks, namely GAM nets, 
    consisting of stateful processors exchanging pointers in fully asynchronous 
    fashion.
    We demonstrate the validity of the proposed approach, from the expressiveness 
    perspective, by showing how GAM nets can be exploited to implement higher-level 
    parallel programming models, such as data and task parallelism.
    As for the performance perspective, the execution of two non-toy benchmarks on 
    a number of different small-scale HPC clusters exhibits both close-to-ideal 
    scalability and negligible overhead with respect to state-of-the-art benchmark 
    implementations.
    For instance, the GAM implementation of a high-quality video restoration filter 
    sustains a 100 fps throughput over 70\%-noisy high-quality video streams on a 
    4-node cluster of Graphics Processing Units (GPUs), with minimal programming 
    effort.},
      author = {Maurizio Drocco},
      date-modified = {2017-10-28 16:19:07 +0000},
      doi = {10.5281/zenodo.1037585},
      keywords = {fastflow, rephrase, toreador, repara, paraphrase},
      month = {October},
      school = {Computer Science Department, University of Torino},
      title = {Parallel Programming with Global Asynchronous Memory: Models, {C++} {API}s and Implementations},
      url = {https://zenodo.org/record/1037585/files/Drocco_phd_thesis.pdf},
      year = {2017},
      bdsk-url-1 = {https://zenodo.org/record/1037585/files/Drocco_phd_thesis.pdf},
      bdsk-url-2 = {http://dx.doi.org/10.5281/zenodo.1037585}
    }

  • M. Torquati, G. Mencagli, M. Drocco, M. Aldinucci, T. D. Matteis, and M. Danelutto, “On Dynamic Memory Allocation in Sliding-Window Parallel Patterns for Streaming Analytics,” The Journal of Supercomputing, 2017. doi:10.1007/s11227-017-2152-1
    [BibTeX] [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.

    @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 Tiziano {De Matteis} and Marco Danelutto},
      date-modified = {2017-06-19 15:48:50 +0000},
      doi = {10.1007/s11227-017-2152-1},
      journal = {The Journal of Supercomputing},
      keywords = {Data Stream Processing, Modern C++, Dynamic Memory Allocation, Multicores, Stream Analytics, Parallel Patterns, rephrase},
      month = sep,
      title = {On Dynamic Memory Allocation in Sliding-Window Parallel Patterns for Streaming Analytics},
      year = 2017,
      bdsk-url-1 = {http://dx.doi.org/10.1007/s11227-017-2152-1}
    }

  • C. Misale, M. Drocco, G. Tremblay, and M. Aldinucci, “PiCo: a Novel Approach to Stream Data Analytics,” in Euro-Par 2017 Workshops, Proc. of the 1st Intl. Workshop on Autonomic Solutions for Parallel and Distributed Data Stream Processing (Auto-DaSP), 2017.
    [BibTeX] [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.

    @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.},
      author = {Claudia Misale and Maurizio Drocco and Guy Tremblay and Marco Aldinucci},
      booktitle = {Euro-Par 2017 Workshops, Proc. of the 1st Intl. Workshop on Autonomic Solutions for Parallel and Distributed Data Stream Processing (Auto-DaSP)},
      date-added = {2017-11-12 10:17:46 +0000},
      date-modified = {2017-11-12 10:30:00 +0000},
      month = aug,
      note = {To appear},
      publisher = {Springer},
      series = {{LNCS}},
      title = {PiCo: a Novel Approach to Stream Data Analytics},
      year = {2017}
    }

  • 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. 1740003, 2017. doi:10.1142/S0129626417400035
    [BibTeX] [Abstract] [Download PDF]

    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-published = {March 2017},
      date-received = {January 2017},
      doi = {10.1142/S0129626417400035},
      eprint = {http://www.worldscientific.com/doi/pdf/10.1142/S0129626417400035},
      journal = {Parallel Processing Letters},
      keywords = {toreador, rephrase, IBM},
      number = {01},
      pages = {1740003},
      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}
    }

2016

  • C. Misale, M. Drocco, M. Aldinucci, and G. Tremblay, “A Comparison of Big Data Frameworks on a Layered Dataflow Model,” in Proc. of HLPP2016: Intl. Workshop on High-Level Parallel Programming, Muenster, Germany, 2016, pp. 1-19. doi:10.5281/zenodo.321866
    [BibTeX] [Abstract] [Download PDF]

    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.},
      address = {Muenster, Germany},
      author = {Claudia Misale and Maurizio Drocco and Marco Aldinucci and Guy Tremblay},
      booktitle = {Proc. of HLPP2016: Intl. Workshop on High-Level Parallel Programming},
      date-added = {2016-06-17 22:15:43 +0000},
      date-modified = {2017-07-13 09:16:30 +0000},
      doi = {10.5281/zenodo.321866},
      keywords = {toreador, rephrase, IBM},
      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}
    }

  • 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 (IJHPCA), pp. 1-16, 2016. doi:10.1177/1094342016668567
    [BibTeX] [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.

    @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 = {2016-10-09 21:55:39 +0000},
      doi = {10.1177/1094342016668567},
      journal = {International Journal of High Performance Computing Applications (IJHPCA)},
      keywords = {fastflow, bioinformatics, repara, rephrase, interomics, mimomics},
      pages = {1--16},
      title = {{NuChart-II}: the road to a fast and scalable tool for {Hi-C} data analysis},
      year = {2016},
      bdsk-url-1 = {http://hdl.handle.net/2318/1607126},
      bdsk-url-2 = {http://dx.doi.org/10.1177/1094342016668567}
    }

  • M. Drocco, C. Misale, and M. Aldinucci, “A Cluster-As-Accelerator approach for SPMD-free Data Parallelism,” in Proc. of Intl. Euromicro PDP 2016: Parallel Distributed and network-based Processing, Crete, Greece, 2016, pp. 350-353. doi:10.1109/PDP.2016.97
    [BibTeX] [Abstract] [Download PDF]

    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.},
      address = {Crete, Greece},
      author = {Maurizio Drocco and Claudia Misale and Marco Aldinucci},
      booktitle = {Proc. of Intl. Euromicro PDP 2016: Parallel Distributed and network-based Processing},
      date-modified = {2016-04-21 17:33:00 +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 = {http://calvados.di.unipi.it/storage/paper_files/2016_pdp_skedato.pdf},
      year = {2016},
      bdsk-url-1 = {http://hdl.handle.net/2318/1611858},
      bdsk-url-2 = {http://calvados.di.unipi.it/storage/paper_files/2016_pdp_skedato.pdf},
      bdsk-url-3 = {http://dx.doi.org/10.1109/PDP.2016.97}
    }

  • M. Aldinucci, M. Danelutto, M. Drocco, P. Kilpatrick, C. Misale, G. P. Pezzi, and M. Torquati, “A Parallel Pattern for Iterative Stencil + Reduce,” Journal of Supercomputing, pp. 1-16, 2016. doi:10.1007/s11227-016-1871-z
    [BibTeX] [Abstract] [Download PDF]

    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-added = {2016-08-19 21:52:17 +0000},
      date-modified = {2016-09-23 07:40:20 +0000},
      doi = {10.1007/s11227-016-1871-z},
      journal = {Journal of Supercomputing},
      keywords = {nvidia, repara, rephrase},
      pages = {1--16},
      title = {A Parallel Pattern for Iterative Stencil + Reduce},
      url = {http://arxiv.org/pdf/1609.04567v1.pdf},
      year = {2016},
      bdsk-url-1 = {http://dx.doi.org/10.1007/s11227-016-1871-z},
      bdsk-url-2 = {http://arxiv.org/pdf/1609.04567v1.pdf}
    }

2015

  • M. Aldinucci, M. Danelutto, M. Drocco, P. Kilpatrick, G. P. 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
    [BibTeX] [Abstract] [Download PDF]

    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.},
      address = {Helsinki, Finland},
      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-added = {2015-07-05 09:48:33 +0000},
      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},
      title = {The Loop-of-Stencil-Reduce paradigm},
      url = {http://calvados.di.unipi.it/storage/paper_files/2015_RePara_ISPA.pdf},
      year = {2015},
      bdsk-url-1 = {http://calvados.di.unipi.it/storage/paper_files/2015_RePara_ISPA.pdf},
      bdsk-url-2 = {http://dx.doi.org/10.1109/Trustcom.2015.628}
    }

  • 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 Intl. Euromicro PDP 2015: Parallel Distributed and network-based Processing, 2015. doi:10.1109/PDP.2015.104
    [BibTeX] [Abstract] [Download PDF]

    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 Intl. Euromicro PDP 2015: Parallel Distributed and network-based Processing},
      date-added = {2014-12-03 13:51:17 +0000},
      date-modified = {2015-09-24 11:16:43 +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 = {http://calvados.di.unipi.it/storage/paper_files/2015_pdp_nuchartff.pdf},
      year = {2015},
      bdsk-url-1 = {http://calvados.di.unipi.it/storage/paper_files/2015_pdp_nuchartff.pdf},
      bdsk-url-2 = {http://dx.doi.org/10.1109/PDP.2015.104}
    }

  • M. Drocco, C. Misale, G. P. Pezzi, F. Tordini, and M. Aldinucci, “Memory-Optimised Parallel Processing of Hi-C Data,” in Proc. of Intl. Euromicro PDP 2015: Parallel Distributed and network-based Processing, 2015, pp. 1-8. doi:10.1109/PDP.2015.63
    [BibTeX] [Abstract] [Download PDF]

    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 neigh- borhood 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 neigh- borhood 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 Intl. Euromicro PDP 2015: Parallel Distributed and network-based Processing},
      date-added = {2014-12-03 13:54:08 +0000},
      date-modified = {2015-09-24 11:17:47 +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 = {http://calvados.di.unipi.it/storage/paper_files/2015_pdp_memopt.pdf},
      year = {2015},
      bdsk-url-1 = {http://calvados.di.unipi.it/storage/paper_files/2015_pdp_memopt.pdf},
      bdsk-url-2 = {http://dx.doi.org/10.1109/PDP.2015.63}
    }

  • 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 Computational Intelligence Methods for Bioinformatics and Biostatistics – 11th International Meeting, CIBB 2014, Cambridge, UK, June 26-28, 2014, Revised Selected Papers, Cambridge, UK, 2015, pp. 298-311. doi:10.1007/978-3-319-24462-4_25
    [BibTeX] [Abstract] [Download PDF]

    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.},
      address = {Cambridge, UK},
      author = {Fabio Tordini and Maurizio Drocco and Ivan Merelli and Luciano Milanesi and Pietro Li{\`o} and Marco Aldinucci},
      booktitle = {Computational Intelligence Methods for Bioinformatics and Biostatistics - 11th International Meeting, {CIBB} 2014, Cambridge, UK, June 26-28, 2014, Revised Selected Papers},
      date-modified = {2015-09-24 11:22:30 +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},
      pages = {298-311},
      publisher = {Springer},
      series = {{LNCS}},
      title = {{NuChart-II}: a graph-based approach for the analysis and interpretation of {Hi-C} data},
      url = {http://calvados.di.unipi.it/storage/paper_files/2014_nuchart_cibb.pdf},
      volume = {8623},
      year = {2015},
      bdsk-url-1 = {http://calvados.di.unipi.it/storage/paper_files/2014_nuchart_cibb.pdf},
      bdsk-url-2 = {http://dx.doi.org/10.1007/978-3-319-24462-4_25}
    }

  • M. Aldinucci, G. P. 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
    [BibTeX] [Abstract] [Download PDF]

    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-added = {2014-08-23 00:06:10 +0000},
      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 = {http://calvados.di.unipi.it/storage/paper_files/2015_ff_stencilreduce_ijhpca.pdf},
      volume = {29},
      year = {2015},
      bdsk-url-1 = {http://calvados.di.unipi.it/storage/paper_files/2015_ff_stencilreduce_ijhpca.pdf},
      bdsk-url-2 = {http://dx.doi.org/10.1177/1094342014567907}
    }

  • 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
    [BibTeX] [Abstract] [Download PDF]

    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-added = {2015-02-01 16:38:47 +0000},
      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}
    }

2014

  • M. Aldinucci, M. Torquati, M. Drocco, G. P. Pezzi, and C. Spampinato, “FastFlow: Combining Pattern-Level Abstraction and Efficiency in GPGPUs,” in GPU Technology Conference (GTC 2014), San Jose, CA, USA, 2014.
    [BibTeX] [Abstract] [Download PDF]

    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 2014)},
      date-added = {2014-04-19 12:52:40 +0000},
      date-modified = {2016-08-19 21:45:39 +0000},
      keywords = {fastflow, gpu, nvidia, impact, paraphrase},
      month = mar,
      title = {FastFlow: Combining Pattern-Level Abstraction and Efficiency in {GPGPUs}},
      url = {http://calvados.di.unipi.it/storage/talks/2014_S4729-Marco-Aldinucci.pdf},
      year = {2014},
      bdsk-url-1 = {http://calvados.di.unipi.it/storage/talks/2014_S4729-Marco-Aldinucci.pdf}
    }

  • M. Aldinucci, M. Torquati, M. Drocco, G. P. Pezzi, and C. Spampinato, “An Overview of FastFlow: Combining Pattern-Level Abstraction and Efficiency in GPGPUs,” in GPU Technology Conference (GTC 2014), San Jose, CA, USA, 2014.
    [BibTeX] [Abstract] [Download PDF]

    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 2014)},
      date-added = {2014-04-13 23:20:52 +0000},
      date-modified = {2016-08-19 21:45:51 +0000},
      keywords = {fastflow, gpu, nvidia, impact, paraphrase},
      month = mar,
      title = {An Overview of FastFlow: Combining Pattern-Level Abstraction and Efficiency in {GPGPUs}},
      url = {http://calvados.di.unipi.it/storage/talks/2014_S4585-Marco-Aldinucci.pdf},
      year = {2014},
      bdsk-url-1 = {http://calvados.di.unipi.it/storage/talks/2014_S4585-Marco-Aldinucci.pdf}
    }

  • 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.
    [BibTeX] [Abstract] [Download PDF]

    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.},
      address = {Fiuggi, Italy},
      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},
      url = {http://calvados.di.unipi.it/storage/paper_files/2014_ACACES_ex-abstract.pdf},
      year = {2014},
      bdsk-url-1 = {http://calvados.di.unipi.it/storage/paper_files/2013_ACACES_ex-abstract.pdf},
      bdsk-url-2 = {http://calvados.di.unipi.it/storage/paper_files/2014_ACACES_ex-abstract.pdf}
    }

  • M. Aldinucci, G. P. 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.
    [BibTeX] [Abstract] [Download PDF]

    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-added = {2013-12-07 18:28:32 +0000},
      date-modified = {2015-09-27 12:42:02 +0000},
      keywords = {fastflow, paraphrase, impact},
      title = {Parallel video denoising on heterogeneous platforms},
      url = {http://calvados.di.unipi.it/storage/paper_files/2014_ff_video_denoiser_hlpgpu.pdf},
      year = {2014},
      bdsk-url-1 = {http://calvados.di.unipi.it/storage/paper_files/2014_ff_video_denoiser_hlpgpu.pdf}
    }

  • M. Aldinucci, M. Drocco, G. P. Pezzi, C. Misale, F. Tordini, and M. Torquati, “Exercising high-level parallel programming on streams: a systems biology use case,” in Proc. of the 2014 IEEE 34th Intl. Conference on Distributed Computing Systems Workshops (ICDCS), Madrid, Spain, 2014. doi:10.1109/ICDCSW.2014.38
    [BibTeX] [Abstract] [Download PDF]

    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.},
      address = {Madrid, Spain},
      author = {Marco Aldinucci and Maurizio Drocco and Guilherme {Peretti Pezzi} and Claudia Misale and Fabio Tordini and Massimo Torquati},
      booktitle = {Proc. of the 2014 IEEE 34th Intl. Conference on Distributed Computing Systems Workshops (ICDCS)},
      date-added = {2014-04-19 12:44:39 +0000},
      date-modified = {2015-09-27 12:43:13 +0000},
      doi = {10.1109/ICDCSW.2014.38},
      keywords = {fastflow, gpu, bioinformatics, paraphrase, impact, nvidia},
      publisher = {IEEE},
      title = {Exercising high-level parallel programming on streams: a systems biology use case},
      url = {http://calvados.di.unipi.it/storage/paper_files/2014_dcperf_cwc_gpu.pdf},
      year = {2014},
      bdsk-url-1 = {http://calvados.di.unipi.it/storage/paper_files/2014_dcperf_cwc_gpu.pdf},
      bdsk-url-2 = {http://dx.doi.org/10.1109/ICDCSW.2014.38}
    }

  • 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
    [BibTeX] [Abstract] [Download PDF]

    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-added = {2014-06-26 21:30:32 +0000},
      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},
      url = {http://downloads.hindawi.com/journals/bmri/2014/207041.pdf},
      year = {2014},
      bdsk-url-1 = {http://calvados.di.unipi.it/storage/paper_files/2014_ff_cwc_bmri.pdf},
      bdsk-url-2 = {http://downloads.hindawi.com/journals/bmri/2014/207041.pdf},
      bdsk-url-3 = {http://dx.doi.org/10.1155/2014/207041}
    }

  • 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
    [BibTeX] [Abstract] [Download PDF]

    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-added = {2014-12-21 17:49:54 +0000},
      date-modified = {2015-09-27 12:33:52 +0000},
      doi = {10.1093/bib/bbt040},
      issn = {1467-5463},
      journal = {Briefings in Bioinformatics},
      keywords = {fastflow, bioinformatics, cloud, paraphrase, impact, biobits},
      number = {5},
      pages = {798-813},
      title = {Parallel stochastic systems biology in the cloud},
      url = {http://calvados.di.unipi.it/storage/paper_files/2013_ff_bio_cloud_briefings.pdf},
      volume = {15},
      year = {2014},
      bdsk-url-1 = {http://dx.doi.org/10.1093/bib/bbt040},
      bdsk-url-2 = {http://calvados.di.unipi.it/storage/paper_files/2013_ff_bio_cloud_briefings.pdf}
    }

2013

  • M. Drocco, “Parallel stochastic simulators in systems biology: the evolution of the species,” Master Thesis, 2013.
    [BibTeX] [Abstract] [Download PDF]

    The stochastic simulation of biological systems is an increasingly popular technique in bioinformatics. It is often an enlightening technique, especially for multi-stable systems whose 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 especially in model tuning. In this work we discuss the main opportunities to speed up the framework by parallelisation on modern multicore and hybrid multicore and distributed platforms, advocating the high-level design of simulators for stochastic systems as a vehicle for building efficient and portable parallel simulators endowed with on-line statistical analysis. In particular, the Calculus of Wrapped Compartments (CWC) Simulator, which is designed according to the FastFlow’s pattern-based approach, is presented and discussed in this work.

    @mastersthesis{tesi:drocco: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 whose 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 especially in model tuning. In this work we discuss the main opportunities to speed up the framework by parallelisation on modern multicore and hybrid multicore and distributed platforms, advocating the high-level design of simulators for stochastic systems as a vehicle for building efficient and portable parallel simulators endowed with on-line statistical analysis. In particular, the Calculus of Wrapped Compartments (CWC) Simulator, which is designed according to the FastFlow's pattern-based approach, is presented and discussed in this work.},
      author = {Maurizio Drocco},
      date-modified = {2013-11-24 00:29:54 +0000},
      keywords = {fastflow},
      month = jul,
      school = {Computer Science Department, University of Torino, Italy},
      title = {Parallel stochastic simulators in systems biology: the evolution of the species},
      url = {http://calvados.di.unipi.it/storage/paper_files/2013_tesi_drocco.pdf},
      year = {2013},
      bdsk-url-1 = {http://calvados.di.unipi.it/storage/paper_files/2013_tesi_drocco.pdf}
    }

  • 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 Intl. Euromicro PDP 2013: Parallel Distributed and network-based Processing, Belfast, Nothern Ireland, U.K., 2013. doi:10.1109/PDP.2013.66
    [BibTeX] [Abstract] [Download PDF]

    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 Intl. Euromicro PDP 2013: Parallel Distributed and network-based Processing},
      date-added = {2012-01-20 19:22:15 +0100},
      date-modified = {2013-11-24 00:30:43 +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},
      url = {http://calvados.di.unipi.it/storage/paper_files/2013_cwc_d_PDP.pdf},
      year = {2013},
      bdsk-url-1 = {http://calvados.di.unipi.it/storage/paper_files/2013_cwc_d_PDP.pdf},
      bdsk-url-2 = {http://dx.doi.org/10.1109/PDP.2013.66}
    }

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
    [BibTeX] [Abstract] [Download PDF]

    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.},
      address = {Istambul, Turkey},
      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-added = {2012-06-04 18:38:01 +0200},
      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},
      url = {http://calvados.di.unipi.it/storage/paper_files/2012_2phasedenoiser_ff_ipta.pdf},
      year = {2012},
      bdsk-url-1 = {http://calvados.di.unipi.it/storage/paper_files/2012_2phasedenoiser_ff_ipta.pdf},
      bdsk-url-2 = {http://dx.doi.org/10.1109/IPTA.2012.6469567}
    }

  • 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 Euro-Par 2011 Workshops, Proc. of the 2st Workshop on High Performance Bioinformatics and Biomedicine (HiBB), Bordeaux, France, 2012, pp. 3-12. doi:10.1007/978-3-642-29740-3_2
    [BibTeX] [Abstract] [Download PDF]

    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.},
      address = {Bordeaux, France},
      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 = {Euro-Par 2011 Workshops, Proc. of the 2st Workshop on High Performance Bioinformatics and Biomedicine (HiBB)},
      date-added = {2010-08-15 00:50:09 +0200},
      date-modified = {2013-11-24 00:35:51 +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},
      url = {http://calvados.di.unipi.it/storage/paper_files/2012_onlinestat_HiBB2011.pdf},
      volume = {7156},
      year = {2012},
      bdsk-url-1 = {http://calvados.di.unipi.it/storage/paper_files/2012_onlinestat_HiBB2011.pdf},
      bdsk-url-2 = {http://dx.doi.org/10.1007/978-3-642-29740-3_2}
    }

  • M. Coppo, F. Damiani, M. Drocco, E. Grassi, E. Sciacca, S. Spinella, and A. Troina, “Simulation techniques for the calculus of wrapped compartments,” Theoretical Computer Science, vol. 431, pp. 75-95, 2012. doi:10.1016/j.tcs.2011.12.063
    [BibTeX] [Abstract]

    The modelling and analysis of biological systems has deep roots in Mathematics, specifically in the field of Ordinary Differential Equations (ODEs). Alternative approaches based on formal calculi, often derived from process algebras or term rewriting systems, provide a quite complementary way to analyse the behaviour of biological systems. These calculi allow to cope in a natural way with notions like compartments and membranes, which are not easy (sometimes impossible) to handle with purely numerical approaches, and are often based on stochastic simulation methods. Recently, it has also become evident that stochastic effects in regulatory networks play a crucial role in the analysis of such systems. Actually, in many situations it is necessary to use stochastic models. For example when the system to be described is based on the interaction of few molecules, when we are at the presence of a chemical instability, or when we want to simulate the functioning of a pool of entities whose compartmentalised structure evolves dynamically. In contrast, stable metabolic networks, involving a large number of reagents, for which the computational cost of a stochastic simulation becomes an insurmountable obstacle, are efficiently modelled with ODEs. In this paper we define a hybrid simulation method, combining the stochastic approach with ODEs, for systems described in the Calculus of Wrapped Compartments (CWC), a calculus on which we can express the compartmentalisation of a biological system whose evolution is defined by a set of rewrite rules.

    @article{DBLP:journals/tcs/CoppoDDGSST12,
      abstract = {The modelling and analysis of biological systems has deep roots in Mathematics, specifically in the field of Ordinary Differential Equations (ODEs). Alternative approaches based on formal calculi, often derived from process algebras or term rewriting systems, provide a quite complementary way to analyse the behaviour of biological systems. These calculi allow to cope in a natural way with notions like compartments and membranes, which are not easy (sometimes impossible) to handle with purely numerical approaches, and are often based on stochastic simulation methods. Recently, it has also become evident that stochastic effects in regulatory networks play a crucial role in the analysis of such systems. Actually, in many situations it is necessary to use stochastic models. For example when the system to be described is based on the interaction of few molecules, when we are at the presence of a chemical instability, or when we want to simulate the functioning of a pool of entities whose compartmentalised structure evolves dynamically. In contrast, stable metabolic networks, involving a large number of reagents, for which the computational cost of a stochastic simulation becomes an insurmountable obstacle, are efficiently modelled with ODEs. In this paper we define a hybrid simulation method, combining the stochastic approach with ODEs, for systems described in the Calculus of Wrapped Compartments (CWC), a calculus on which we can express the compartmentalisation of a biological system whose evolution is defined by a set of rewrite rules.},
      author = {Mario Coppo and Ferruccio Damiani and Maurizio Drocco and Elena Grassi and Eva Sciacca and Salvatore Spinella and Angelo Troina},
      bibsource = {DBLP, http://dblp.uni-trier.de},
      date-added = {2013-12-12 22:28:07 +0000},
      date-modified = {2013-12-13 10:37:47 +0000},
      doi = {10.1016/j.tcs.2011.12.063},
      ee = {http://dx.doi.org/10.1016/j.tcs.2011.12.063},
      journal = {Theoretical Computer Science},
      pages = {75-95},
      title = {Simulation techniques for the calculus of wrapped compartments},
      volume = {431},
      year = {2012},
      bdsk-url-1 = {http://dx.doi.org/10.1016/j.tcs.2011.12.063}
    }

2011

  • C. Calcagno, M. Coppo, F. Damiani, M. Drocco, E. Sciacca, S. Spinella, and A. Troina, “Modelling Spatial Interactions in the Arbuscular Mycorrhizal Symbiosis using the Calculus of Wrapped Compartments,” in Proc. of Third International Workshop on Computational Models for Cell Processes (CompMod), Aachen, Germany, 2011, pp. 3-18.
    [BibTeX] [Abstract]

    Arbuscular mycorrhiza (AM) is the most wide-spread plant-fungus symbiosis on earth. Investigating this kind of symbiosis is considered one of the most promising ways to develop methods to nurture plants in more natural manners, avoiding the complex chemical productions used nowadays to produce artificial fertilizers. In previous work we used the Calculus of Wrapped Compartments (CWC) to investigate different phases of the AM symbiosis. In this paper, we continue this line of research by modelling the colonisation of the plant root cells by the fungal hyphae spreading in the soil. This study requires the description of some spatial interaction. Although CWC has no explicit feature modelling a spatial geometry, the compartment labelling feature can be effectively exploited to define a discrete surface topology outlining the relevant sectors which determine the spatial properties of the system under consideration. Different situations and interesting spatial properties can be modelled and analysed in such a lightweight framework (which has not an explicit notion of geometry with coordinates and spatial metrics), thus exploiting the existing CWC simulation tool.

    @inproceedings{DBLP:journals/corr/abs-1109-1363,
      abstract = {Arbuscular mycorrhiza (AM) is the most wide-spread plant-fungus symbiosis on earth. Investigating this kind of symbiosis is considered one of the most promising ways to develop methods to nurture plants in more natural manners, avoiding the complex chemical productions used nowadays to produce artificial fertilizers. In previous work we used the Calculus of Wrapped Compartments (CWC) to investigate different phases of the AM symbiosis. In this paper, we continue this line of research by modelling the colonisation of the plant root cells by the fungal hyphae spreading in the soil. This study requires the description of some spatial interaction. Although CWC has no explicit feature modelling a spatial geometry, the compartment labelling feature can be effectively exploited to define a discrete surface topology outlining the relevant sectors which determine the spatial properties of the system under consideration. Different situations and interesting spatial properties can be modelled and analysed in such a lightweight framework (which has not an explicit notion of geometry with coordinates and spatial metrics), thus exploiting the existing CWC simulation tool.},
      address = {Aachen, Germany},
      author = {Cristina Calcagno and Mario Coppo and Ferruccio Damiani and Maurizio Drocco and Eva Sciacca and Salvatore Spinella and Angelo Troina},
      bibsource = {DBLP, http://dblp.uni-trier.de},
      booktitle = {Proc. of Third International Workshop on Computational Models for Cell Processes (CompMod)},
      date-added = {2013-12-12 22:25:03 +0000},
      date-modified = {2013-12-13 10:32:18 +0000},
      editor = {Ion Petre and Erik P. de Vink},
      ee = {http://dx.doi.org/10.4204/EPTCS.67.3},
      month = sep,
      pages = {3-18},
      series = {EPTCS},
      title = {Modelling Spatial Interactions in the Arbuscular Mycorrhizal Symbiosis using the Calculus of Wrapped Compartments},
      volume = {67},
      year = {2011}
    }

  • M. Aldinucci, M. Coppo, F. Damiani, M. Drocco, M. Torquati, and A. Troina, “On Designing Multicore-Aware Simulators for Biological Systems,” in Proc. of Intl. Euromicro PDP 2011: Parallel Distributed and network-based Processing, Ayia Napa, Cyprus, 2011, pp. 318-325. doi:10.1109/PDP.2011.81
    [BibTeX] [Abstract] [Download PDF]

    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.},
      address = {Ayia Napa, Cyprus},
      author = {Marco Aldinucci and Mario Coppo and Ferruccio Damiani and Maurizio Drocco and Massimo Torquati and Angelo Troina},
      booktitle = {Proc. of Intl. Euromicro PDP 2011: Parallel Distributed and network-based Processing},
      date-added = {2012-02-25 01:21:25 +0000},
      date-modified = {2013-11-24 00:37:16 +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},
      url = {http://calvados.di.unipi.it/storage/paper_files/2011_ff_cwc_sim_PDP.pdf},
      year = {2011},
      bdsk-url-1 = {http://arxiv.org/pdf/1010.2438v2},
      bdsk-url-2 = {http://calvados.di.unipi.it/storage/paper_files/2011_ff_cwc_sim_PDP.pdf},
      bdsk-url-3 = {http://dx.doi.org/10.1109/PDP.2011.81}
    }

  • M. Coppo, F. Damiani, M. Drocco, E. Grassi, M. Guether, and A. Troina, “Modelling Ammonium Transporters in Arbuscular Mycorrhiza Symbiosis,” Transactions on Computational Systems Biology (TCS), vol. 6575, iss. 13, pp. 85-109, 2011. doi:10.1007/978-3-642-19748-2_5
    [BibTeX] [Abstract]

    The Stochastic Calculus of Wrapped Compartments (SCWC) is a recently proposed variant of the Stochastic Calculus of Looping Sequences (SCLS), a language for the representation and simulation of biological systems. In this work we apply SCWC to model a newly discovered ammonium transporter. This transporter is believed to play a fundamental role for plant mineral acquisition, which takes place in the arbuscular mycorrhiza, the most wide-spread plant-fungus symbiosis on earth. Investigating this kind of symbiosis is considered one of the most promising ways to develop methods to nurture plants in more natural manners, avoiding the complex chemical productions used nowadays to produce artificial fertilizers. In our experiments the passage of NH3/NH4+ from the fungus to the plant has been dissected in known and hypothetical mechanisms; with the model so far we have been able to simulate the behavior of the system under different conditions. Our simulations confirmed some of the latest experimental results about the LjAMT2;2 transporter. Moreover, by comparing the behaviour of LjAMT2;2 with the behaviour of another ammonium transporter which exists in plants, viz. LjAMT1;1, our simulations support an hypothesis about why LjAMT2;2 is so selectively expressed in arbusculated cells.

    @article{DBLP:journals/tcsb/Coppo/DDGGT11,
      abstract = {The Stochastic Calculus of Wrapped Compartments (SCWC) is a recently proposed variant of the Stochastic Calculus of Looping Sequences (SCLS), a language for the representation and simulation of biological systems. In this work we apply SCWC to model a newly discovered ammonium transporter. This transporter is believed to play a fundamental role for plant mineral acquisition, which takes place in the arbuscular mycorrhiza, the most wide-spread plant-fungus symbiosis on earth. Investigating this kind of symbiosis is considered one of the most promising ways to develop methods to nurture plants in more natural manners, avoiding the complex chemical productions used nowadays to produce artificial fertilizers. In our experiments the passage of NH3/NH4+ from the fungus to the plant has been dissected in known and hypothetical mechanisms; with the model so far we have been able to simulate the behavior of the system under different conditions.  Our simulations confirmed some of the latest experimental results about the LjAMT2;2 transporter. Moreover, by comparing the behaviour of LjAMT2;2 with the behaviour of another ammonium transporter which exists in plants, viz. LjAMT1;1, our simulations support an hypothesis about why LjAMT2;2 is so selectively expressed in arbusculated cells.},
      author = {Mario Coppo and Ferruccio Damiani and Maurizio Drocco and Elena Grassi and Mike Guether and Angelo Troina},
      date-added = {2013-12-12 22:25:24 +0000},
      date-modified = {2014-08-24 22:03:51 +0000},
      doi = {10.1007/978-3-642-19748-2_5},
      journal = {Transactions on Computational Systems Biology (TCS)},
      number = {13},
      pages = {85-109},
      title = {Modelling Ammonium Transporters in Arbuscular Mycorrhiza Symbiosis},
      volume = {6575},
      year = {2011},
      bdsk-url-1 = {http://dx.doi.org/10.1007/978-3-642-19748-2_5}
    }

2010

  • M. Coppo, F. Damiani, M. Drocco, E. Grassi, E. Sciacca, S. Spinella, and A. Troina, “Hybrid Calculus of Wrapped Compartments,” in Proc. of 4th Workshop on Membrane Computing and Biologically Inspired Process Calculi (MeCBIC), Jena, Germany, 2010, pp. 102-120.
    [BibTeX] [Abstract]

    The modelling and analysis of biological systems has deep roots in Mathematics, specifically in the field of ordinary differential equations (ODEs). Alternative approaches based on formal calculi, often derived from process algebras or term rewriting systems, provide a quite complementary way to analyze the behaviour of biological systems. These calculi allow to cope in a natural way with notions like compartments and membranes, which are not easy (sometimes impossible) to handle with purely numerical approaches, and are often based on stochastic simulation methods. Recently, it has also become evident that stochastic effects in regulatory networks play a crucial role in the analysis of such systems. Actually, in many situations it is necessary to use stochastic models. For example when the system to be described is based on the interaction of few molecules, when we are at the presence of a chemical instability, or when we want to simulate the functioning of a pool of entities whose compartmentalised structure evolves dynamically. In contrast, stable metabolic networks, involving a large number of reagents, for which the computational cost of a stochastic simulation becomes an insurmountable obstacle, are efficiently modelled with ODEs. In this paper we define a hybrid simulation method, combining the stochastic approach with ODEs, for systems described in CWC, a calculus on which we can express the compartmentalisation of a biological system whose evolution is defined by a set of rewrite rules.

    @inproceedings{DBLP:journals/corr/abs-1011-0494,
      abstract = {The modelling and analysis of biological systems has deep roots in Mathematics, specifically in the field of ordinary differential equations (ODEs). Alternative approaches based on formal calculi, often derived from process algebras or term rewriting systems, provide a quite complementary way to analyze the behaviour of biological systems. These calculi allow to cope in a natural way with notions like compartments and membranes, which are not easy (sometimes impossible) to handle with purely numerical approaches, and are often based on stochastic simulation methods. Recently, it has also become evident that stochastic effects in regulatory networks play a crucial role in the analysis of such systems. Actually, in many situations it is necessary to use stochastic models. For example when the system to be described is based on the interaction of few molecules, when we are at the presence of a chemical instability, or when we want to simulate the functioning of a pool of entities whose compartmentalised structure evolves dynamically. In contrast, stable metabolic networks, involving a large number of reagents, for which the computational cost of a stochastic simulation becomes an insurmountable obstacle, are efficiently modelled with ODEs. In this paper we define a hybrid simulation method, combining the stochastic approach with ODEs, for systems described in CWC, a calculus on which we can express the compartmentalisation of a biological system whose evolution is defined by a set of rewrite rules.},
      address = {Jena, Germany},
      author = {Mario Coppo and Ferruccio Damiani and Maurizio Drocco and Elena Grassi and Eva Sciacca and Salvatore Spinella and Angelo Troina},
      bibsource = {DBLP, http://dblp.uni-trier.de},
      booktitle = {Proc. of 4th Workshop on Membrane Computing and Biologically Inspired Process Calculi (MeCBIC)},
      date-added = {2013-12-12 22:24:23 +0000},
      date-modified = {2013-12-13 10:30:02 +0000},
      editor = {Gabriel Ciobanu and Maciej Koutny},
      ee = {http://dx.doi.org/10.4204/EPTCS.40.8},
      month = aug,
      pages = {102-120},
      series = {EPTCS},
      title = {Hybrid Calculus of Wrapped Compartments},
      volume = {40},
      year = {2010}
    }

  • M. Coppo, F. Damiani, M. Drocco, E. Grassi, and A. Troina, “Stochastic Calculus of Wrapped Compartments,” in Proc. of the 8th Workshop on Quantitative Aspects of Programming Languages (QAPL), Paphos, Cyprus, 2010, pp. 82-98.
    [BibTeX] [Abstract]

    The Calculus of Wrapped Compartments (CWC) is a variant of the Calculus of Looping Sequences (CLS). While keeping the same expressiveness, CWC strongly simplifies the development of automatic tools for the analysis of biological systems. The main simplification consists in the removal of the sequencing operator, thus lightening the formal treatment of the patterns to be matched in a term (whose complexity in CLS is strongly affected by the variables matching in the sequences). We define a stochastic semantics for this new calculus. As an application we model the interaction between macrophages and apoptotic neutrophils and a mechanism of gene regulation in E.Coli.

    @inproceedings{DBLP:journals/corr/abs-1006-5099,
      abstract = {The Calculus of Wrapped Compartments (CWC) is a variant of the Calculus of Looping Sequences (CLS). While keeping the same expressiveness, CWC strongly simplifies the development of automatic tools for the analysis of biological systems. The main simplification consists in the removal of the sequencing operator, thus lightening the formal treatment of the patterns to be matched in a term (whose complexity in CLS is strongly affected by the variables matching in the sequences).
    We define a stochastic semantics for this new calculus. As an application we model the interaction between macrophages and apoptotic neutrophils and a mechanism of gene regulation in E.Coli.},
      address = {Paphos, Cyprus},
      author = {Mario Coppo and Ferruccio Damiani and Maurizio Drocco and Elena Grassi and Angelo Troina},
      bibsource = {DBLP, http://dblp.uni-trier.de},
      booktitle = {Proc. of the 8th Workshop on Quantitative Aspects of Programming Languages (QAPL)},
      date-added = {2013-12-12 22:24:44 +0000},
      date-modified = {2013-12-13 10:31:45 +0000},
      editor = {Alessandra Di Pierro and Gethin Norman},
      ee = {http://dx.doi.org/10.4204/EPTCS.28.6},
      month = mar,
      pages = {82-98},
      series = {EPTCS},
      title = {Stochastic Calculus of Wrapped Compartments},
      volume = {28},
      year = {2010}
    }