You are here: Home Deliverables

Deliverables

D2-1 Initial generic patterns report

This is the first deliverable of Work Package 2 "Parallel patterns." Its main aim is to describe an initial set of parallel patterns provided to ParaPhrase users–the application programmers–to support the development of efficient parallel applications targeting heterogeneous architectures.

D2-1.pdf — PDF document, 1243 kB (1272848 bytes)

D2-2 Homogeneous Implementation of Initial Generic Patterns

This is the deliverable D2.2. It aims at describing the implementation of the initial generic pattern-set defined in deliverable D2.1. This initial set of parallel patterns has been explicitly designed to be minimal but able to exploit the most common patterns of parallelism in typical parallel applications. The implementation refers to two different frameworks: FastFlow, which is based on a C++ technology, and Erlang, which is instead a functional programming language. Both implementations target homogeneous architectures.

D2-2.pdf — PDF document, 1487 kB (1523378 bytes)

D2-2 Prototype sources

Sources of the prototype implementation of D2.1 parallel design patterns described in deliverable D2.2. Both FastFlow/C++ and Erlang implementation are included.

ParaPhrase-D2.2-Software.tar.gz — Tar archive, 1180 kB (1209012 bytes)

D3-1 Software/Hardware Virtualisation Interfaces

This deliverable introduces the component-level interfaces that form the target of the software/hardware virtualisation interfaces in the ParaPhrase project and show these can be instantiated using both C/C++ and Erlang, when taken together with concrete information about the design patterns and skeletons that are used as part of the implementation. It comprises a key technical deliverable, that is expected to be maintained as a “living document" and pdated in line with experience that is gained throughout the course of the project.

D3-1.pdf — PDF document, 1225 kB (1254679 bytes)

D4-1 Initial Pattern Transformation System

This deliverable (4.1) is the first in Work Package 4: Parallel Refactoring Tools. Its primary purpose is to describe an initial parallel pattern transformation system that supports the refactoring of programs into systems with increased parallelism, but equivalent functionality. The refactoring system has a database of initial transformations, supporting the Skeletons outlined in Deliverable 2.1.

D4-1.pdf — PDF document, 1495 kB (1531232 bytes)

D5-1 Hardware Virtualisation API Report

The Hardware Virtualisation API Report (D5.1) is the first deliverable of Work Package 5. In the deliverable the ParaPhrase Hardware Abstraction Layer (HAL) is introduced. It represents the specification of a common low level layer of abstraction for subsequent work within ParaPhrase. The objective is to specify a set of low level primitives which allow for the composition of parallel programs upon heterogeneous architectures.

D5-1.pdf — PDF document, 1831 kB (1875073 bytes)

D6-1 Requirements Analysis

This deliverable captures the initial requirements of the ParaPhrase project, as defined at the start of the project by the project team as a whole, and forming the basis for the successful conduct of the project. It covers technical requirements relating to all aspects of the project and to all the technical workpackages, including applications, refactoring, remapping, parallel patterns, skeleton implementations, component and hardware virtualisation. The deliverable is a key input into all the technical workpackages.

D6-1.pdf — PDF document, 637 kB (652931 bytes)

D8-1 Initial Press Release

The ParaPhrase project has been concurrently announced in Europe and in the USA. This deliverable describes the “Initial Press Release” activity which included five media communications and several media appearances (see News)

D8-1.pdf — PDF document, 944 kB (966781 bytes)

D8-2 Project Web Site

This document describes the ParaPhrase portal. The portal is intended to be the core of the ParaPhrase virtual organization by providing a web-based platform for information exchange within the virtual community.

D8-2.pdf — PDF document, 1128 kB (1155930 bytes)

D8-3 Report on first project workshop

This deliverable presents a summary of the first ParaPhraseworkshop, co-located with HiPEAC2012 held in Paris (France) on Monday 23 January 2012. Entitled HLPGPU: High-level programming for heterogeneous and hierarchical parallel systems, the workshop presented four contributions. Such four contributions were subsequently published as a special issue Special Issue on HighLevel Programming for Heterogeneous and Hierarchical Parallel Systems, edited by Gaétan Hains and Frédéric Gava (LACL, Université Paris-Est, France), and Kevin Hammond (University of St. Andrews, UK)

D8-3.pdf — PDF document, 580 kB (594506 bytes)

D8-4 Initial Plans to use and Disseminate Foreground Knowledge

This document describes overall plans for the use and dissimination of foreground knowledge in the ParaPhrase project. It describes the dissemination activities that have taken place at each of the consortium partners in the first year of the projects, outlines the general plans for the use and dissmenination of knowledge at each partner, and describes concrete dissemination plans for year 2 of the project.

D8-4.pdf — PDF document, 512 kB (524306 bytes)

D2-4 Prototype sources

Deliverable D2.1 introduced the initial set of generic patterns for the Para- Phrase project. The patterns in the initial set can be used to implement parallel applications according to the structured parallel programming methodology that is typical of the design patterns and/or algorithmic skeletons approaches. Deliverable D2.2 described the implementation of the initial set of patterns targeting homogeneous multicore architectures. This deliverable describes the implementation of the initial generic pattern set on heterogeneous architectures, that is on architectures containing both multicore CPUs and General Purpose GPUs (GPGPUs). We focus on the implementation of the data parallel patterns from the initial pat- tern set (map and reduce), since the task parallel patterns that were described there (pipeline and farm) do not fit the data parallel execution model that is typical of GPGPUs. This deliverable describes two different implementations of the initial data parallel patterns. The first implementation provides data parallel skeletons implementing the initial data parallel pattern set on GPUs. These are provided as suitable FastFlow abstractions. The second implementation provides similar skeletons as Erlang functions that can be seamlessly used in any Erlang program. In both cases, the GPU implementation of the data parallel skeletons runs on top of OpenCL, although some CUDA support is also provided.

Read More…

D5-2 Implementation of low-level component support

This Deliverable consists of a software prototype accompanied by this short tech- nical note sketching the main design choices adopted in the software and explaining how to obtain and run the software. This document is accompanied by three software packages. • ParaPhraseVM-v3.tar: A Linux x86_86 virtual machine (VM) image with D5.2 software installed. The virtual machine can be opened in either Oracle VirtualBox or VMWare players. Due to current VM technology limitations (GP)GPU hardware cannot be accessed from within the VM. Most of the tests designed for (GP)GPUs can be run on CPUs using OpenCL Intel run-time support. The VM includes joint material from both D5.2 and D2.4. • fastflow-2.0.1.tar.gz:The source code and instructions of the C/C++ WP5 development framework with tests and examples (see Sec. 2). This package also includes material from D2.4. • Erlang-0.3.tar.gz:The source code and instructions of the Erlang WP5 development framework (see Sect. 3). Note that this package depends on OpenCL, OpenCL cannot currently be used within a Virtualbox VM environment since this system is missing the required fglrx kernel module.

Read More…

D6-4 Applications Porting Report

This deliverable is a description of the porting work done in the ParaPhrase project. Its aims, the status, issues encountered, and next steps are discussed. After a slow start due to the early project start and the need to acquaint the developers with technology new to them, communication and progress have intensified over the last months. Now, with a delay of approximately one month, the goals for D6.4 have been reached, and all use cases are available in a basic or even complete parallelized version. Most of the technology currently available in ParaPhrase is applied in one or the other use case, notable exceptions so far being GPGPU and distributed patterns. They can now serve as basis for technology evaluation, and feedback has already been provided to technological workpackage partners. While conceptually simple to apply, the pattern based approach of ParaPhrase has shown some issues in its current implementation state when practically applied to the use cases. One main issue is the complexity of porting work, especially on the C++ side, which is currently being addressed by work on refactoring for C++. Another issue was the need for explicit synchronization and intensive fine tuning of communication among workers (threads), to achieve reasonable scaling. Partially this optimization work is still in progress, and ParaPhrase will have to show in future how refactoring, application specific and heterogeneous patterns, and static and dynamic mapping can address this. This deliverable is accompanied by two further ones. D6.3 (confidential to project partners and commission services) provides information about access to ported code and the evaluation platform. D6.5 contains the evaluation of the use cases for which porting is described here.

D6-4.pdf — PDF document, 1103 kB (1129844 bytes)

D6-5 First report on Experimental Evaluation

This report gives a detailed description of the experimental validation of the Fast- Flow programming model, particularly for C++ and Erlang. For some of the applications, in particular those originally written in C or C++, the porting work was challenging, in particular when the application logic and its implementation in C++ classes had to be refactored to accommodate the FastFlow library for optimization. In fact, one of the motivations for this task, was to evaluate FastFlow for real world applications, not only academic small scale test kernels. The encountering of issues was therefore anticipated. It is worth noting, that most issues encountered by the application developers have been either fixed, or a feasi- ble work-around provided until a fix is available (see D6.4). However, all applications have been ported successfully to the FastFlow programming model, some showing already encouraging performance, others just as proof of concept without claiming significant performance increase over the sequential version. The tangible results of this task are FastFlow enabled applications with the encouraging perspective for successful follow-up performance optimization, and the identification of performance problems to be addressed by the FastFlow developers.

D6-5.pdf — PDF document, 747 kB (765197 bytes)

D6-3

The content of this deliverable is confidential.

Read More…

D3-2 Static Mapping Implementation

This deliverable describes a new technique for static mapping, i.e., assigning software components to heterogeneous hardware resources using a Monte-Carlo Tree Search. We introduce a new methodology for programming heterogeneous parallel systems, building on the work in WP4 on refactoring tools using static mappings derived using MCTS to gain near-optimal mappings. We also provide a number of use-cases, including an industrial use-case from HLRS, demonstrating that we are able to gain, with our methodology, near-optimal mappings. Finally we introduce PEI, a Performance Enhancement Infrastructure which is a collection of mechanisms and policies used for improving the performance of skeleton based frameworks for use with the static mapping.

Read More…

D2-6 Initial Implementation of Application-Specific Patterns

This deliverable describes the initial implementation of a subset of application specific and high level patterns among those described in Deliverable [3] and [2]. The implementation we consider here is only targeting heterogeneous hardware plat- forms, being heterogeneous platform the subject of another, forthcoming deliver- able. We selected the set of patterns to implement on the basis of the priorities expressed by the beneficiaries, in particular by those involved in the WP6 (Use cases) activities. The patterns considered more useful or more urgent to be introduced in a prototype implementation has been developed in order to provide them a test framework on which starting to write code following the ParaPhrase methodology. As a consequence, in the next deliverable it could happen that slight modification will occur (maybe in the type or number of parameters for specific calls or in the adding of new/still not included methods) but the overall programming infrastructure can be considered assessed. The deliverable is divided in two major parts: Chapter 2 describes the application specific pattern implemented on top of FastFlow; Chapter 3 presents the patterns implemented on top of the Erlang platform. The set of patterns is not exactly the same in the two cases, as of the different use cases and necessities by the beneficiaries implementing applications and use cases with C++/FastFlow and Erlang ParaPhrase frameworks. The deliverable introduces each of the implemented domain specific or high level pattern by showing its programmatic interface and sample usage code. The positioning of this deliverable is outlined in Fig. 1. It is based on the list of application specific patterns reported in [2] and their implementation will definitively assessed by D2.8 (Final homogenous implementation) and D2.7 (Het- erogenous implementation of application specific patterns).

Read More…

D6-2 Application Requirements and Use Case Scenarios

This deliverable describes the applications and use case scenarios selected by the partners that are active in WP6 (Use Cases, Requirements and Evaluation). Use case selection and evaluation criteria are given. Some selected and proposed core use cases are detailed, organized by the application area of a respective project partner. Further requirements, targeted hardware, and expected use case results are specified. Also, potential for the use of the generic patterns (deliverable D2.1) and application specific patterns (deliverable D2.3) are mentioned. The annex gives information about further use cases potentially relevant further on in the project or as dissemination and exploitation opportunities. The parallel patterns and the use cases are expected to evolve together and mu- tually depend on each other, during the duration of the ParaPhrase project. Thus, the state of the use cases is expected to adapt to the evolution of the implemented parallel patterns and to further opportunities for use cases with high impact in the Erlang, industrial, and High Performance Computing communities.

D6-2-revision2.pdf — PDF document, 581 kB (595831 bytes)

D2-3 Application-Specific Patterns Report

This is the third deliverable of the Work Package 2 Parallel patterns. It provides the description of an initial set of domain specific parallel patterns. These patterns have been identified by analyzing the requirements provided by the different “ap- plication” communities contributing to the project. In particular, three different application domains have been considered, namely symbolic computation, numer- ical computation and soft computing domains. For each domain, an initial set of domain specific patterns has been identified. Within each set of domain specific patterns a “representative” pattern has been identified and its characterizing properties have been described using the method- ology of the software engineering parallel pattern community. Last but not least, for the identified representative patterns we have outlined possible implementation strategies using the core, “RISC” patterns introduced in D2.1 (the “Initial generic patterns report” [18]) and whose implementation is discussed in D2.2 (“Homoge- neous implementation of initial generic patterns” [17]), which constitute the “ba- sic building blocks” of parallel applications according to the general ParaPhrase project design. These implementation strategies are aimed at establishing a gen- eral domain specific pattern implementation methodology suitable for supporting the implementation of any of the domain specific patterns considered within the project. It is worth pointing out that, as the project evolves, we expect to extend this first set of domain specific patterns with new patterns suggested from the project beneficiaries contributing to the use case work package (WP6). As far as this deliverable is concerned, we will use C++/FastFlow code snip- pets to illustrate the implementation strategies of domain specific patterns. As the code refers to the same skeletons implemented in Erlang, the overall methodology naturally extends to the Erlang ParaPhrase framework. The placement of this deliverable within WP2 and, more generally, within the project, is illustrated in Fig. 1, on the following page.

D2-3.pdf — PDF document, 1213 kB (1242343 bytes)

D2-5 Final Pattern Definition Report

The deliverable reports on the parallel patterns identified by the project beneficiaries as useful to support the development of generic parallel application as well as of the specific use cases identified by the beneficiaries contributing to WP6. The identified parallel patterns are described in two different parts of the document. The patterns listed in Chap. 2 are the ones needed to implement the WP6 use cases or the ones already demonstrated useful in a wide range of parallel applications. We expect these patterns will all be provided–by the end of the project–as suitable (composition of) skeletons implemented in C++/FastFlow and/or in Erlang, according to the framework(s) used to implement the use cases. We expect as well that for these patterns WP4 will provide suitable refactoring support and WP3 will provide appropriate mapping/scheduling policies. The patterns in Chap. 3 in- stead, are parallel patterns that have anyway been identified as useful ones, but that will not be implemented within the ParaPhrase project, as the implementation work will concentrate on more basic patterns and on those patterns actually needed to support the use case implementation. The description of the patterns within the deliverable is high level and given ac- cordingly to the style usually adopted when describing design patterns: the pattern (1), the functional and non functional parameters needed to instantiate the pattern (2) and a short description of the associated parallelism exploitation strategies and policies (3) are given for each one of the patterns. The pattern description is intentionally concise such that on the one hand the key aspects of the pattern are all evidenced and on the other hand we do not engage describing the implementation details that will eventually be influenced by a number of technical aspects that may be correctly taken into account only when the actual implementation of these patterns will be considered.

D2-5.pdf — PDF document, 701 kB (718551 bytes)

D4-3 Refactoring User Interfaces

In this deliverable we describe the user interfaces associated with the refactoring tools as developed under WP4. In particular, we show the user interface for the C++ refactoring tool, as described in D4.2, and the Erlang refactoring tool user interface, as described in Deliverable D4.1. In addition to the refactoring tools user interfaces, we also describe a preliminary user interface prototype for the pattern discovery system.

D4-3.pdf — PDF document, 1730 kB (1771660 bytes)

D8-5 Report on Second Project Workshop

This deliverable presents a summary of the second ParaPhraseworkshop, which was co-located with HiPEAC 2013 and took place in Berlin (Germany) on Monday 24 January 2013. The workshop was entitled "HLPGPU: High-level Programming for Heterogeneous and Hierarchical Parallel Systems", and consisted of 6 presentations. Chapter 1 contains a brief description of the workshop and its aims. In Chapter 2, we provide the program and abstracts of each presentation. A list of publications arising from this work is given in Chapter 3.

D8-5.pdf — PDF document, 419 kB (429111 bytes)

D7-1 Report on first standalone user community workshop

The objective of WP7 is to promote the use of ParaPhrase tools and technologies by establishing an active user community and by providing technical documentation as well as elaborated tutorials and training materials. This deliverable describes the first standalone User Workshop that was held by SCCH in Hagenberg, Austria, with roughly 50 participants including strong participation from local industry. In addition, the deliverable describes various tutorials, workshops, presentations and other related events that have been run by the Consortium in association with developer and other potential user conferences and other events in order to promote a general user community. Finally, it describes a range of technical documentation and training materials, including online videos, for the tools and software frame- works that have been developed in the remainder of the project. This material serves to support user community building activities, providing support for potential users of the various ParaPhrase technologies. Finally, this deliverable itemizes concrete plans for further community building activities to be implemented in the third year of the project.

D7-1.pdf — PDF document, 414 kB (424473 bytes)

D4-2 Enhanced Pattern Transformation System

Deliverable D4.1 introduced the initial pattern transformation system. In addition to describing an initial refactoring tool for Erlang, D4.1 also described a number of new refactorings for Erlang, such as Introduce Pipeline, Introduce Farm and Introduce Map. This deliverable describes the enhanced pattern transformation system, where we describe a new refactoring tool implemented for C++ in the Eclipse IDE. Fol- lowing the same trend as in D4.1, we also introduce a number of new refactorings for C++ and FastFlow, such as Introduce Pipeline and Introduce Farm. In addition, we also introduce a new Component class, and provide a refactoring to shape C++ code into a hygienic state ready for parallelisation. We also provide a number of use-cases demonstrating the C++ refactoring tool against a set of examples taken from the Industrial Partners, SCCH and HLRS.

D4-2.pdf — PDF document, 941 kB (963815 bytes)

D8-6 Revised Plan to use and Disseminate Foreground Knowledge

This document updates progress and plans for the use and dissemination of fore- ground knowledge in the ParaPhrase project. It describes the dissemination activities that have taken place at each of the consortium partners during the first and second year of the project, outlines the general plans for the use and dissemination of knowledge at each partner, and describes concrete dissemination plans for the third year of the project. It is noted that the project has overall produced 32 publications in the second year, and we are well posed to continue a healthy dissemination effort aligned with our initial estimate of 30-50 publications overall. In fact, we are expecting to produce a ParaPhrase special issue to be published in Springer’s Computer Science Research & Development late next year.

D8-6.pdf — PDF document, 517 kB (530425 bytes)

D6-7 MAS Framework and Use cases Report

This deliverable describes the multi-agent applications and use case scenarios selected by AGH within WP6 (Use Cases, Requirements and Evaluation). We describe the motivation and evaluation criteria for these use cases, along with details of particular example algorithms and simulations. We also formulate high-level multi-agent patterns which can be used to model the chosen use cases and show how these high-level patterns may be expressed in terms of the generic patterns (deliverable D2.1) and application specific patterns (deliverable D2.3) provided by Paraphrase.

D6-7.pdf — PDF document, 483 kB (495203 bytes)

D2-10 Pattern Amenability

This deliverable reports on the exemplars and findings we collected and made related to the possibilities of automatic discovery of Paraphrase patterns in Erlang programs.

D2-10.pdf — PDF document, 710 kB (727691 bytes)

D2-11 Initial Pattern Discovery

In this deliverable we describe the initial pattern discovery analysis. In particular, we show the calls to specific library functions and the language constructs where a skeleton can be introduced. We also describe how we identify these pattern can- didates. In addition to this, we show the prototype identification of map-like and pipeline-like recursive functions.

D2-11.pdf — PDF document, 959 kB (982905 bytes)