My research interests are mainly in the field of parallel and distributed computing. That is, in methodologies, programming models, support tools and environments for parallel and distributed computing on multiprocessors, networks and grids. I'm currently involved in the development of parallel programming frameworks based on algorithmic skeletons/design patterns, including FastFlow and Ocaml parmap. I've been and I'm involved in different research (projects), including the new STREP project ParaPhrase, started October 1st, 2011, and related to algorithmic skeletons used to target heterogeneous multicores. Here you can access the Univ. of Pisa page related to my research activity (in italian).

I've been one of the main designers of P3L the (Pisa Parallel Programming Language) and I designed and I maintained the muskel full Java skeleton based programming library in early '2000. I currently contribute to the development and maintainance of FastFlow.

FastFlow is a parallel programming framework for multi-core platforms based upon non-blocking lock-free/fence-free synchronization mechanisms. The framework is composed of a stack of layers that progressively abstracts out the programming of shared-memory parallel applications. The goal of the stack is twofold: to ease the development of applications and make them very fast and scalable. FastFlow is particularly targeted to the development of streaming applications and is implemented as a set of C++ classes running on top of Posix Pthreads. FastFlow is developed on Intel/Linux architectures, but ports exist targeting Windows, AMD and Tilera. Recently FastFlow has been also ported to ARM architectures.

In the past:

• I've been one of the main designers of P3L in the '90 (the Pisa Parallel Programming Language, a skeleton based programming language originally developed by the Dept. of Computer Science of the Univ. of Pisa and the Hewlett Packard Pisa Science Center) and of the OcamlP3L library
• I've been involved in the design of ASSIST programming environment that was originally developed in the framework of the GRID.it national project.
• I developed and maintained **muskel**, Muskel has been designed and implemented in early '2000 as a experimental scenario to experiment several different concepts. First, the application manager concept has been introduced and experimented, i.e. the concept of an autonomous entity taking completely care of executing in parallel the skeleton program, without any programmer intervention but providing the program, the input and output streams and a performance contract. Then, muskel has been used to demonstrate the feasibility of providing skeleton set extendability. Programmers can implement their own skeletons by providing a low level macro data flow graph description. Then the skeleton can be used in any place where another muskel skeleton may be used. More recently, muskel has been modified to support single multi-core and multi-core COW/NOWs target architectures.

I proposed since early '2000 the adoption of Macro Data Flow models to support the implementation of structured parallel programming frameworks (Marco Danelutto: Efficient Support for Skeletons on Workstation Clusters. Parallel Processing Letters 11(1): 41-56 (2001)). We demonstrated different results related to Macro Data Flow, in particular:

• advantages deriving from the usage of Macro Data Flow vs. template based implementation of algorithmic skeleton frameworks
• management of GPU co-processors through Macro Data Flow (Marco Aldinucci, Marco Danelutto, Peter Kilpatrick, Massimo Torquati: Targeting Heterogeneous Architectures via Macro Data Flow. Parallel Processing Letters 22(2) (2012))
• efficiency of Macro Data Flow in the implementation of structured parallel applications targeting multicores (Marco Aldinucci, L. Anardu, Marco Danelutto, Massimo Torquati, Peter Kilpatrick: Parallel Patterns + Macro Data Flow for Multi-core Programming. Euromicro PDP 2012: 27-36, IEEE press)

I've been responsible of the “Non Functional Component Features” work package in the GridCOMP STREP project, where we completed the design of the GCM Behavioural skeletons originally developed within the Programming model Institute of CoreGRID. Within GridCOMP a reference implementation of a couple of Behavioural skeletons (a task farm and a data parallel functional replication behavioural skeletons) have been implemented with an autonomic manager completely taking care of performance tuning aspects (See GridCOMP web site).

More recently, we demonstrated feasibility of both hierarchical, single concern and multi concern autonomic management of structured parallel computations.

• Hierarchical single concern management is used when structured parallel computations such as the ones deriving from source code programmed by nesting algorithmic skeletons (parallel patterns) are used. Each skeleton (according to the Behavioural skeleton methodology) has its own autonomic manager and coordination is needed to allow suitable decisions to be taken and shared among the autonomic skeleton hierarchy, as well as to propagate the user supplied SLA through the manager hierarchy.
• Multi concern management also requires coordination among managers, under the assumption autonomous and independent autonomic manager (hierarchies) exist, each taking case of a single non functional concern (e.g. performance, security, power management, fault tolerance)

I've been responsible of the Programming model Institute within the CoreGRID EU NoE. The Institute designed the GCM (Grid Component Model) that has been later on implemented within the GridCOMP EU STREP project on top of ProActive. Our main contribution to GCM has been related to the design and development of the Behavioural skeletons, GCM components modelling notable parallelism exploitation patterns and provided with autonomic managers taking care of non functional concerns (e.g. performance tuning).

The work on Behavioural skeletons and on the associate autonomic management constituted and currently constitutes my main research area.

In 2008-2009 I participated to the design of STKM (the Spatio-Temporal Skeleton component Model) derived from STCM (the Spatio-Temporal Skeleton component Model) adding skeleton component assemblies.

Within the Grid.IT Italian national FIRB project, I leaded the workpage that designed and implemented the ASSIST programming environment targeting grids as well as NOW/COWs. My main contribution to the ASSIST design concerned the introduction of the components and of the performance self-tuning features.

Within the CoreGRID EU NoE and the GridCOMP I participated to the design and development of the GCM (Grid Component Model) (see above) and to different research activities mostly related to the subject of grid programming models. During this period I also participated to the activities of the EU NGG working group that led to the introduction of the SOKU concept. More recently, I participated to the activities of the Dagstuhl seminar 09082, Feb. 2009, Perspectives Workshop: The Future of Grid Computing.

I'm currently investigating programming models most suitable to exploit multi/many core and heterogeneous architectures. In particular, my research interest is in moving skeleton technology to the fine grain, heterogenous technology typical of chips that have been recently introduced or announced.

Preliminary results presented at PARCO'09 demonstrate the portability of muskel skeleton framework originally developed for COW/NOW target architectures to state-of-the-art multicore systems, both in terms of functionality and in terms of performance (scalability).

A C++ version of the muskel skeleton framework (currently implemented in Java) is under development, to test the feasibility of seamless targeting of mixes CPU and GPU cores under the control of the skeleton framework application manager.

I experimented feasibility of using Services for the implementation of skeleton based programming environments. With G. Zoppi, a prototype of a subset of the muskel skeleton programming environment has been developed on top of Tuscany/SCA that first included a rule based (JBoss) autonomic manager taking care of performance tuning.