D2.1: Report on the initial pattern set
The deliverable is the initial deliverable from WP2 "Pattern-Based Parallel Software Engineering".
It hosts i) the initial, high level design of the RePhrase pattern set and ii) a preliminary outline of the RePhrase parallel pattern DSL. The deliverable is the result of the first phase of WP2 (and Task 2.1, "Patterns for Data-intensive and Parallel Applications") where, according to the DoW we will identify and develop a fundamental set of commonly used patterns found in C++ applications (such as map-reduce, farm and pipeline), together with the part of the DSL that describes them. As shown in the Figure, the deliverable contents impact on the rest of the activities of WP2, provide inputs to the activities inWP3 aimed at ensuring reliability, robustness and integrity of structured parallel software, and constitute a kind of base target framework for the adaptivity strategies and techniques developed inWP4.
It hosts i) the initial, high level design of the RePhrase pattern set and ii) a preliminary outline of the RePhrase parallel pattern DSL. The deliverable is the result of the first phase of WP2 (and Task 2.1, "Patterns for Data-intensive and Parallel Applications") where, according to the DoW we will identify and develop a fundamental set of commonly used patterns found in C++ applications (such as map-reduce, farm and pipeline), together with the part of the DSL that describes them. As shown in the Figure, the deliverable contents impact on the rest of the activities of WP2, provide inputs to the activities inWP3 aimed at ensuring reliability, robustness and integrity of structured parallel software, and constitute a kind of base target framework for the adaptivity strategies and techniques developed inWP4.
| d2-1.pdf |
D2.2: Software for the Initial Refactoring Tool
Parallelising sequential applications is usually a very hard job, due to many different ways in which an application can be parallelised and a large number of programming models (each with its own advantages and disadvantages) that can be used.In this paper, we describe a method to semi-automatically generate and evaluate different parallelisations of the same application, allowing programmers to find the best parallelisation without significant manual reengineering of the code.We describe a novel, high-level domain-specific language,Refactoring Pattern Language (RPL), that is used to represent the parallel structure of an application and to capture its extra-functional properties.We then describe a set of RPL rewrite rules that can be used to generate alternative,but semantically equivalent, parallel structures (parallelisations) of the same application.We also describe the RPL Shell that can be used to evaluate these parallelisations,in terms of the desired extra-functional properties. Finally, we describe a set ofC++ refactorings, targeting OpenMP, Intel TBB and FastFlow parallel programming models, that semi-automatically apply the desired parallelisation to the applications source code, therefore giving a parallel version of the code.We demonstrate how the RPL and the refactoring rules can be used to derive efficient parallelisations of two realistic C++ use cases.
| d2-2-public.pdf |
D2.3: Report on shaping and pattern discovery for initial patterns
This document is the third deliverable from WP2 "Pattern-Based Parallel Software Engineering". It provides the following contributions i) a coherent, complete and formalised set of parallel patterns for data-intensive applications, together with a domain specific language (DSL) to represent them; ii) pattern implementations on top of existing parallel programming frameworks; iii) a pattern discovery methodology (for widely used legacy and existing parallel applications); iv) C++ program shaping/componentisation techniques; and v) refactoring rules and tool-support for the introduction and tuning of parallel patterns in both new and existing C++ applications.This deliverable, D2.3 "Report on program shaping and pattern discovery for the initial pattern set.w, integrates the results of the different phases of WP2 (T2.3 "Program Shaping" and T2.4 "Pattern Discovery") where, according to the DoW we will report the initial program shaping methods and describe the pattern discovery techniques for the initial pattern set. The work in this deliverable is divided in two steps. First, it defines the program shaping techniques and methods for the initial pattern set of RePhrase. These techniques allow refactoring of sequential C++ programs into hygienic C++ code with equivalent functionality by eliminating non-hygienic code properties, such as side-effects and unnecessary task/data dependencies. The second step holds two sub-steps: it defines pattern candidates along with their conditions and properties to be introduced in C++ applications; and presents a prototype for pattern discovery that, using the aforementioned conditions, identifies instances of parallel pattern candidates within C++ applications.
| d2-3.pdf |
D2.4: Software for implementations of initial patterns
This document is the fourth deliverable from WP2 "Pattern-Based Parallel Software Engineering" and it basically describes the features and contents of the software packages building the "Software for implementations of initial patterns" as described in the amended DoW. In particular, D2.4 integrates the results of the a crucial phase of WP2 (T2.2 "Pattern implementation") where, according to the amended DoW we will implement an initial set of patterns identified in the first phase of T2.1, supporting threading mechanisms (e.g. pthreads, C++11/14 standard), general parallel programming models either as a library (e.g. Intel TBB, FastFlow) or compiler supported (e.g. OpenMP), and GPU programming models (e.g. OpenCL,CUDA).The deliverable details three different software contributions: i) a uniform C++11 pattern interface along with an implementation of the patterns in D2.1 on top of C++ threads, OpenMP, Intel TBB and Thrust, ii) a partial implementation of the C++ pattern interface API on top of FastFlow, outlining the pros and cons of the API implementation in terms of performance, and iii) a complete implementation of the D2.1 patterns in FastFlow, provided through standard FastFlow native interface.
| d2-4.pdf |
D2.5: Advanced patterns
This deliverable is the fifth WP2 ("Pattern-Based Parallel Software Engineering") deliverable. It comes at mid project to host all those patterns not initially included in the first deliverable (D2.1 "Report on the initial pattern set", produced at M6 and including some well know, general purpose patterns) but some how "needed" to support the project use cases as well as some different applications currently developed by the project beneficiaries.The deliverable therefore includes some new patterns divided into two main categories: "high level patterns", that may be used to model the entire (or a large part of the) parallel structure of an application and "building block" patterns, that may be used in composition with other patterns to model and support more complex parallel application structures.
| d2-5.pdf |
D2.6: Software for the Advanced Refactoring Tool
This deliverable reports on the second phase of Task 2.5 Pattern Based Refactoring Tool Support. In this second phase, we extend the refactoring tool to target GrPPI, the abstract pattern interface from D2.5. In particular we introduce new refactorings that target farms and pipelines in GrPPI, with refactoring extensions to introduce pipeline and farm refactorings. With this new refactoring interface, soft- ware developers can take advantage of the general abstract mechanisms of GrPPI to target different underlying pattern implementations, including PThreads, TBB, OpenMP, FastFlow and CUDA.
| d2-6public.pdf |
D2.7: Final Report on Patterns and Relationship with General Design Patterns
The deliverable reports on the RePhrase experience related to the usage of the parallel design patterns with respect to the assessed results and experiences concerning parallel design patterns in general. The first part of the paper introduces and dis- cusses the general design pattern concepts. Then we summarize the pattern design experience through RePhrase and eventually we assess our main achievements w.r.t. the most general parallel pattern concepts and experiences, both related to usability and to specific aspects as developed during the project so far.
| d2-7.pdf |
D2.8: Software for implementations of advanced patterns
This document is the eighth deliverable from WP2 “Pattern-Based Parallel Software Engineering” and it basically describes the features and contents of the soft- ware packages building the “Software for implementations of advanced patterns” as described in the amended DoW. In particular, D2.8 integrates the results of the a crucial phase of WP2 (T2.2 “Pattern implementation”) where, according to the amended DoW we will extend the pattern implementations to cover the advanced patterns that were identified in the second phase of T2.1, also supporting thread- ing mechanisms (e.g. pthreads, C++11/14 standard), general parallel programming models either as a library (e.g. Intel TBB, FastFlow) or compiler supported (e.g. OpenMP), and GPU programming models (e.g. OpenCL,CUDA).
| d2-8.pdf |
D2.9: Report on shaping and pattern discovery for advanced patterns
This document is the ninth deliverable from WP2 “Pattern-Based Parallel Software Engineering”. It provides the following contributions i) a coherent, complete and formalised set of parallel patterns for data-intensive applications, together with a domain specific language (DSL) to represent them; ii) pattern implementations on top of existing parallel programming frameworks; iii) a pattern discovery methodology (for widely used legacy and existing parallel applications); iv) C++ program shaping/componentisation techniques; and v) refactoring rules and tool-support for the introduction and tuning of parallel patterns in both new and existing C++ applications.
| d2-9.pdf |
D2.10: Software for the final refactoring tool
This deliverable reports on the third and final phase of Task 2.5 Pattern Based Refactoring Tool Support. In this final phase, we further extend the GrPPI refactorings from the previous deliverable, D2.6, to target some of the advanced pattern set. In particular, we introduce new refactorings that introduce advanced GrPPI patterns including stencil, divide and conquer and map reduce. In addition to these advanced patterns, we have also extended and improved the original pipeline refactorings as stated in D2.6.
| d2-10-public.pdf |
THE REPHRASE PROJECT
Copyright © 2018
