Paraphrasing: generating parallel programs using refactoring

Christopher Mark Brown; Kevin Hammond; Marco Danelutto; Peter Kilpatrick; Holger Schöner; Tino Breddin

doi:10.1007/978-3-642-35887-6_13

Paraphrasing: generating parallel programs using refactoring

Christopher Mark Brown, Kevin Hammond, Marco Danelutto, Peter Kilpatrick, Holger Schöner, Tino Breddin

Research output: Chapter in Book/Report/Conference proceeding › Conference contribution

Abstract

Refactoring is the process of changing the structure of a program without changing its behaviour. Refactoring has so far only really been deployed effectively for sequential programs. However, with the increased availability of multicore (and, soon, manycore) systems, refactoring can play an important role in helping both expert and non-expert parallel programmers structure and implement their parallel programs. This paper describes the design of a new refactoring tool that is aimed at increasing the programmability of parallel systems. To motivate our design, we refactor a number of examples in C, C++ and Erlang into good parallel implementations, using a set of formal pattern rewrite rules.

Original language	English
Title of host publication	Formal Methods for Components and Objects
Subtitle of host publication	10th International Symposium, FMCO 2011, Turin, Italy, October 3-5, 2011, Revised Selected Papers
Editors	Bernhard Beckert, Ferruccio Damiani, Frank S. de Boer, Marcello M. Bonsangue
Place of Publication	Berlin, Heidelberg
Publisher	Springer
Pages	237-256
Number of pages	12
ISBN (Electronic)	9783642358876
ISBN (Print)	9783642358869
DOIs	https://doi.org/10.1007/978-3-642-35887-6_13
Publication status	Published - 2013
Event	10th Symposium on Formal Methods for Components and Objects - Turin, Italy Duration: 3 Oct 2011 → 5 Oct 2011 Conference number: 10

Publication series

Name	Lecture Notes in Computer Science (Programming and Software Engineering)
Publisher	Springer
Volume	7542
ISSN (Print)	0302-9743

Conference

Conference	10th Symposium on Formal Methods for Components and Objects
Abbreviated title	FMCO
Country/Territory	Italy
City	Turin
Period	3/10/11 → 5/10/11

Access to Document

10.1007/978-3-642-35887-6_13

FMCORefactoring
© 2013, Springer-Verlag Berlin Heidelberg. This work has been made available online in accordance with the publisher's policies. This is the author created accepted version manuscript following peer review and as such may differ slightly from the final published version. The final published version of this work is available at https://doi.org/10.1007/978-3-642-35887-6_13
Accepted author manuscript, 612 KB

ParaPhrase FP7-ICT-2011-7: EU FP7 'ParaPhrase'
Hammond, K. (PI)
European Commission
1/10/11 → 31/03/15
Project: Standard
HPC-GAP: High performance computational: HPC-GAP High Performance Computational Algebra and Discrete Mathematics
Linton, S. A. (PI), Gent, I. P. (CoI) & Hammond, K. (CoI)
EPSRC
1/09/09 → 28/02/14
Project: Standard

Cite this

Brown, C. M., Hammond, K., Danelutto, M., Kilpatrick, P., Schöner, H., & Breddin, T. (2013). Paraphrasing: generating parallel programs using refactoring. In B. Beckert, F. Damiani, F. S. de Boer, & M. M. Bonsangue (Eds.), Formal Methods for Components and Objects: 10th International Symposium, FMCO 2011, Turin, Italy, October 3-5, 2011, Revised Selected Papers (pp. 237-256). (Lecture Notes in Computer Science (Programming and Software Engineering); Vol. 7542). Springer. https://doi.org/10.1007/978-3-642-35887-6_13

Brown, Christopher Mark ; Hammond, Kevin ; Danelutto, Marco et al. / Paraphrasing : generating parallel programs using refactoring. Formal Methods for Components and Objects: 10th International Symposium, FMCO 2011, Turin, Italy, October 3-5, 2011, Revised Selected Papers. editor / Bernhard Beckert ; Ferruccio Damiani ; Frank S. de Boer ; Marcello M. Bonsangue. Berlin, Heidelberg : Springer, 2013. pp. 237-256 (Lecture Notes in Computer Science (Programming and Software Engineering)).

@inproceedings{90b26216cf6f4be1929398d1a196fb36,

title = "Paraphrasing: generating parallel programs using refactoring",

abstract = "Refactoring is the process of changing the structure of a program without changing its behaviour. Refactoring has so far only really been deployed effectively for sequential programs. However, with the increased availability of multicore (and, soon, manycore) systems, refactoring can play an important role in helping both expert and non-expert parallel programmers structure and implement their parallel programs. This paper describes the design of a new refactoring tool that is aimed at increasing the programmability of parallel systems. To motivate our design, we refactor a number of examples in C, C++ and Erlang into good parallel implementations, using a set of formal pattern rewrite rules.",

author = "Brown, {Christopher Mark} and Kevin Hammond and Marco Danelutto and Peter Kilpatrick and Holger Sch{\"o}ner and Tino Breddin",

note = "Funding: This work has been supported by the European Union grants RII3-CT-2005- 026133 SCIEnce: Symbolic Computing Infrastructure in Europe, IST-2010- 248828 ADVANCE: Asynchronous and Dynamic Virtualisation through performance ANalysis to support Concurrency Engineering, and IST-2011-288570 ParaPhrase: Parallel Patterns for Adaptive Heterogeneous Multicore Systems, and by the UK{\textquoteright}s Engineering and Physical Sciences Research Council grant EP/G055181/1 HPC-GAP: High Performance Computational Algebra; 10th Symposium on Formal Methods for Components and Objects, FMCO ; Conference date: 03-10-2011 Through 05-10-2011",

year = "2013",

doi = "10.1007/978-3-642-35887-6_13",

language = "English",

isbn = "9783642358869",

series = "Lecture Notes in Computer Science (Programming and Software Engineering)",

publisher = "Springer",

pages = "237--256",

editor = "Bernhard Beckert and Ferruccio Damiani and {de Boer}, {Frank S.} and Bonsangue, {Marcello M.}",

booktitle = "Formal Methods for Components and Objects",

address = "Netherlands",

}

Brown, CM, Hammond, K, Danelutto, M, Kilpatrick, P, Schöner, H & Breddin, T 2013, Paraphrasing: generating parallel programs using refactoring. in B Beckert, F Damiani, FS de Boer & MM Bonsangue (eds), Formal Methods for Components and Objects: 10th International Symposium, FMCO 2011, Turin, Italy, October 3-5, 2011, Revised Selected Papers. Lecture Notes in Computer Science (Programming and Software Engineering), vol. 7542, Springer, Berlin, Heidelberg, pp. 237-256, 10th Symposium on Formal Methods for Components and Objects, Turin, Italy, 3/10/11. https://doi.org/10.1007/978-3-642-35887-6_13

Paraphrasing: generating parallel programs using refactoring. / Brown, Christopher Mark; Hammond, Kevin; Danelutto, Marco et al.
Formal Methods for Components and Objects: 10th International Symposium, FMCO 2011, Turin, Italy, October 3-5, 2011, Revised Selected Papers. ed. / Bernhard Beckert; Ferruccio Damiani; Frank S. de Boer; Marcello M. Bonsangue. Berlin, Heidelberg: Springer, 2013. p. 237-256 (Lecture Notes in Computer Science (Programming and Software Engineering); Vol. 7542).

Research output: Chapter in Book/Report/Conference proceeding › Conference contribution

TY - GEN

T1 - Paraphrasing

T2 - 10th Symposium on Formal Methods for Components and Objects

AU - Brown, Christopher Mark

AU - Hammond, Kevin

AU - Danelutto, Marco

AU - Kilpatrick, Peter

AU - Schöner, Holger

AU - Breddin, Tino

N1 - Conference code: 10

PY - 2013

Y1 - 2013

N2 - Refactoring is the process of changing the structure of a program without changing its behaviour. Refactoring has so far only really been deployed effectively for sequential programs. However, with the increased availability of multicore (and, soon, manycore) systems, refactoring can play an important role in helping both expert and non-expert parallel programmers structure and implement their parallel programs. This paper describes the design of a new refactoring tool that is aimed at increasing the programmability of parallel systems. To motivate our design, we refactor a number of examples in C, C++ and Erlang into good parallel implementations, using a set of formal pattern rewrite rules.

AB - Refactoring is the process of changing the structure of a program without changing its behaviour. Refactoring has so far only really been deployed effectively for sequential programs. However, with the increased availability of multicore (and, soon, manycore) systems, refactoring can play an important role in helping both expert and non-expert parallel programmers structure and implement their parallel programs. This paper describes the design of a new refactoring tool that is aimed at increasing the programmability of parallel systems. To motivate our design, we refactor a number of examples in C, C++ and Erlang into good parallel implementations, using a set of formal pattern rewrite rules.

U2 - 10.1007/978-3-642-35887-6_13

DO - 10.1007/978-3-642-35887-6_13

M3 - Conference contribution

SN - 9783642358869

T3 - Lecture Notes in Computer Science (Programming and Software Engineering)

SP - 237

EP - 256

BT - Formal Methods for Components and Objects

A2 - Beckert, Bernhard

A2 - Damiani, Ferruccio

A2 - de Boer, Frank S.

A2 - Bonsangue, Marcello M.

PB - Springer

CY - Berlin, Heidelberg

Y2 - 3 October 2011 through 5 October 2011

ER -

Brown CM, Hammond K, Danelutto M, Kilpatrick P, Schöner H, Breddin T. Paraphrasing: generating parallel programs using refactoring. In Beckert B, Damiani F, de Boer FS, Bonsangue MM, editors, Formal Methods for Components and Objects: 10th International Symposium, FMCO 2011, Turin, Italy, October 3-5, 2011, Revised Selected Papers. Berlin, Heidelberg: Springer. 2013. p. 237-256. (Lecture Notes in Computer Science (Programming and Software Engineering)). doi: 10.1007/978-3-642-35887-6_13

Paraphrasing: generating parallel programs using refactoring

Abstract

Publication series

Conference

Access to Document

Fingerprint

Projects

ParaPhrase FP7-ICT-2011-7: EU FP7 'ParaPhrase'

HPC-GAP: High performance computational: HPC-GAP High Performance Computational Algebra and Discrete Mathematics

Cite this