Skip to content

Research at St Andrews

RPL: a domain-specific language for designing and implementing parallel C++ applications

Research output: Chapter in Book/Report/Conference proceedingConference contribution

DOI

Standard

RPL : a domain-specific language for designing and implementing parallel C++ applications. / Janjic, Vladimir; Brown, Christopher Mark; MacKenzie, Kenneth William; Hammond, Kevin; Danelutto, Marco; Aldinucci, Marco; Garcia, Daniel J.

2016 24th Euromicro International Conference on Parallel, Distributed, and Network-Based Processing (PDP). ed. / Y Cotronis; M Daneshtalab; G A Papadopoulos. Institute of Electrical and Electronics Engineers Inc., 2016. p. 288-295 7445342.

Research output: Chapter in Book/Report/Conference proceedingConference contribution

Harvard

Janjic, V, Brown, CM, MacKenzie, KW, Hammond, K, Danelutto, M, Aldinucci, M & Garcia, DJ 2016, RPL: a domain-specific language for designing and implementing parallel C++ applications. in Y Cotronis, M Daneshtalab & GA Papadopoulos (eds), 2016 24th Euromicro International Conference on Parallel, Distributed, and Network-Based Processing (PDP)., 7445342, Institute of Electrical and Electronics Engineers Inc., pp. 288-295, Euromicro International Conference on Parallel, Distributed, and Network-Based Processing, Heraklion, Crete, Greece, 17/02/16. https://doi.org/10.1109/PDP.2016.122

APA

Janjic, V., Brown, C. M., MacKenzie, K. W., Hammond, K., Danelutto, M., Aldinucci, M., & Garcia, D. J. (2016). RPL: a domain-specific language for designing and implementing parallel C++ applications. In Y. Cotronis, M. Daneshtalab, & G. A. Papadopoulos (Eds.), 2016 24th Euromicro International Conference on Parallel, Distributed, and Network-Based Processing (PDP) (pp. 288-295). [7445342] Institute of Electrical and Electronics Engineers Inc.. https://doi.org/10.1109/PDP.2016.122

Vancouver

Janjic V, Brown CM, MacKenzie KW, Hammond K, Danelutto M, Aldinucci M et al. RPL: a domain-specific language for designing and implementing parallel C++ applications. In Cotronis Y, Daneshtalab M, Papadopoulos GA, editors, 2016 24th Euromicro International Conference on Parallel, Distributed, and Network-Based Processing (PDP). Institute of Electrical and Electronics Engineers Inc. 2016. p. 288-295. 7445342 https://doi.org/10.1109/PDP.2016.122

Author

Janjic, Vladimir ; Brown, Christopher Mark ; MacKenzie, Kenneth William ; Hammond, Kevin ; Danelutto, Marco ; Aldinucci, Marco ; Garcia, Daniel J. / RPL : a domain-specific language for designing and implementing parallel C++ applications. 2016 24th Euromicro International Conference on Parallel, Distributed, and Network-Based Processing (PDP). editor / Y Cotronis ; M Daneshtalab ; G A Papadopoulos. Institute of Electrical and Electronics Engineers Inc., 2016. pp. 288-295

Bibtex - Download

@inproceedings{528aa8dc55e945a1b5dd8e81ae8ac533,
title = "RPL: a domain-specific language for designing and implementing parallel C++ applications",
abstract = "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 (such as service time). 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 of C++ refactorings, targeting OpenMP, Intel TBB and FastFlow parallel programming models, that semi-automatically apply the desired parallelisation to the application's 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 (Image Convolution and Ant Colony Optimisation).",
keywords = "Algorithmic skeletons, Design patterns, Domain specific language, Parallelism, Performance, Structured parallel programming",
author = "Vladimir Janjic and Brown, {Christopher Mark} and MacKenzie, {Kenneth William} and Kevin Hammond and Marco Danelutto and Marco Aldinucci and Garcia, {Daniel J}",
note = "This work has been partially supported by EU FP7-ICT-2013-10 project REPARA (No. 609666) and EU H2020-ICT-2014-1 project RePhrase (No. 644235).",
year = "2016",
month = "3",
day = "31",
doi = "10.1109/PDP.2016.122",
language = "English",
isbn = "9781467387750",
pages = "288--295",
editor = "Y Cotronis and M Daneshtalab and Papadopoulos, {G A}",
booktitle = "2016 24th Euromicro International Conference on Parallel, Distributed, and Network-Based Processing (PDP)",
publisher = "Institute of Electrical and Electronics Engineers Inc.",
address = "United States",

}

RIS (suitable for import to EndNote) - Download

TY - GEN

T1 - RPL

T2 - a domain-specific language for designing and implementing parallel C++ applications

AU - Janjic, Vladimir

AU - Brown, Christopher Mark

AU - MacKenzie, Kenneth William

AU - Hammond, Kevin

AU - Danelutto, Marco

AU - Aldinucci, Marco

AU - Garcia, Daniel J

N1 - This work has been partially supported by EU FP7-ICT-2013-10 project REPARA (No. 609666) and EU H2020-ICT-2014-1 project RePhrase (No. 644235).

PY - 2016/3/31

Y1 - 2016/3/31

N2 - 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 (such as service time). 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 of C++ refactorings, targeting OpenMP, Intel TBB and FastFlow parallel programming models, that semi-automatically apply the desired parallelisation to the application's 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 (Image Convolution and Ant Colony Optimisation).

AB - 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 (such as service time). 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 of C++ refactorings, targeting OpenMP, Intel TBB and FastFlow parallel programming models, that semi-automatically apply the desired parallelisation to the application's 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 (Image Convolution and Ant Colony Optimisation).

KW - Algorithmic skeletons

KW - Design patterns

KW - Domain specific language

KW - Parallelism

KW - Performance

KW - Structured parallel programming

U2 - 10.1109/PDP.2016.122

DO - 10.1109/PDP.2016.122

M3 - Conference contribution

SN - 9781467387750

SP - 288

EP - 295

BT - 2016 24th Euromicro International Conference on Parallel, Distributed, and Network-Based Processing (PDP)

A2 - Cotronis, Y

A2 - Daneshtalab, M

A2 - Papadopoulos, G A

PB - Institute of Electrical and Electronics Engineers Inc.

ER -

Related by author

  1. The Missing Link! A new skeleton for evolutionary multi-agent systems in Erlang

    Stypka, J., Turek, W., Byrski, A., Kisiel-Dorohinicki, M., Barwell, A. D., Brown, C. M., Hammond, K. & Janjic, V., Feb 2018, In : International Journal of Parallel Programming. 46, 1, p. 4-22 19 p.

    Research output: Contribution to journalArticle

  2. Lapedo: hybrid skeletons for programming heterogeneous multicore machines in Erlang

    Janjic, V., Brown, C. M. & Hammond, K., Apr 2016, Parallel Computing: On the Road to Exascale. Joubert, G. R., Leather, H., Parsons, M., Peters, F. & Sawyer, M. (eds.). IOS Press, p. 185-195 (Advances in Parallel Computing; vol. 27).

    Research output: Chapter in Book/Report/Conference proceedingConference contribution

  3. Space exploration using parallel orbits: a study in parallel symbolic computing

    Janjic, V., Brown, C. M., Neunhoeffer, M., Hammond, K., Linton, S. A. & Loidl, H-W., Sep 2013, Parallel Computing: Accelerating Computational Science and Engineering (CSE). Bader, M., Bode, A., Bungartz, H-J., Gerndt, M., Joubert, G. R. & Peters, F. (eds.). IOS Press, Vol. 25. p. 225-232 8 p. (Advances in Parallel Computing).

    Research output: Chapter in Book/Report/Conference proceedingConference contribution

  4. Mapping parallel programs to heterogeneous CPU/GPU architectures using a Monte Carlo Tree Search

    Goli, M., McCall, J., Brown, C. M., Janjic, V. & Hammond, K., 20 Jun 2013, 2013 IEEE Congress on Evolutionary Computation, CEC 2013. IEEE, p. 2932-2939 8 p.

    Research output: Chapter in Book/Report/Conference proceedingConference contribution

ID: 244718744