A language-independent parallel refactoring framework

Brown, Christopher; Hammond, Kevin; Danelutto, Marco; Kilpatrick, Peter

doi:10.1145/2328876.2328884

Cited by 10 publications

(4 citation statements)

References 13 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…Current studies have shown that refactoring provided support for the mainstream parallel programming languages and parallel libraries. Brown et al (2012) presented a language-independent parallel refactoring framework that was not limited to a specific language andaimed to improve the programmability of parallel systems by applying well-defined refactoring. This framework leveraged high-level design pattern rewrite rules to introduce parallelism.…”

Section: Results For Rq5mentioning

confidence: 99%

A survey of concurrency-oriented refactoring

Zhang

2020

Concurrent Engineering

View full text Add to dashboard Cite

Refactoring has become an effective approach to convert sequential programs into concurrent programs. Many refactoring algorithms and tools are proposed to assist developers in writing high-performance concurrent programs. Although researchers actively conduct surveys on refactoring, we are not aware of any survey that summarizes, categorizes and discusses concurrency-oriented refactoring. To this end, this paper presents a survey that investigates how refactoring assists with concurrent programming. To the best of our knowledge, this paper is the first survey that summarizes the state-of-the-art, concurrency-oriented refactoring. First, we design six research questions addressing the concurrent structure, programming language, performance improvement and consistency evaluation. Second, we answer these questions by examining the related papers and then present the results to show how refactoring provides support for concurrent programming after a decade of development, such as transforming the concurrent structures, supporting parallel language, and improving performance. Finally, we summarize the related works and present the future trends.

show abstract

Section: Results For Rq5mentioning

confidence: 99%

A survey of concurrency-oriented refactoring

Zhang

2020

Concurrent Engineering

View full text Add to dashboard Cite

show abstract

“…In future work, we intend to explore which programming patterns (e.g., Skeletons [7]) fit within our system.…”

Section: Resultsmentioning

confidence: 99%

Type-Driven Development of Concurrent Communicating Systems

Brady

2017

csci

View full text Add to dashboard Cite

Modern software systems rely on communication; for example, mobile applications communicating with a central server, distributed systems coordinating a telecommunications network, or concurrent systems handling events and processes in a desktop application. However, reasoning about concurrent programs is hard since we must reason about each process and the order in which communication might happen between processes. In this paper, I describe a type-driven approach to implementing communicating concurrent programs using the dependently typed programming language Idris. I show how the type system can be used to describe resource access protocols (such as controlling access to a file handle) and verify that the programs correctly follow those protocols. Finally, I show how to use the type system to reason about the order of communication between concurrent processes, ensuring that each end of a communication channel follows a defined protocol.

show abstract

“…[2,7]) plus fundamental hylomorphism laws [31]. For example, a parallel pipeline structure ( ) is functionally equivalent to a function composition; a task farm farm can be introduced for any structure; and divide-andconquer dc and feedback fb skeletons can both be derived from hylomorphisms.…”

Section: The Structure-annotated Type Systemmentioning

confidence: 99%

Automatically deriving cost models for structured parallel processes using hylomorphisms

Castro

Hammond

Sarkar

et al. 2018

Future Generation Computer Systems

Self Cite

View full text Add to dashboard Cite

Please cite this article as: D. Castro, et al., Automatically deriving cost models for structured parallel processes using hylomorphisms, Future Generation Computer Systems (2017), http://dx.doi.org/10.1016/j.future. 2017.04.035 This is a PDF file of an unedited manuscript that has been accepted for publication. As a service to our customers we are providing this early version of the manuscript. The manuscript will undergo copyediting, typesetting, and review of the resulting proof before it is published in its final form. Please note that during the production process errors may be discovered which could affect the content, and all legal disclaimers that apply to the journal pertain. An operational semantics of a queue language for streaming computations.  An operational semantics of algorithmic skeletons using this queue language.  Derive cost equations for algorithmic skeletons from the operational semantics.  Cost equations for algorithmic skeletons are combined with sized types. AbstractStructured parallelism using nested algorithmic skeletons can greatly ease the task of writing parallel software, since common, but hard-to-debug, problems such as race conditions are eliminated by design. However, choosing the best combination of algorithmic skeletons to yield good parallel speedups for a specific program on a specific parallel architecture is still a difficult problem. This paper uses the unifying notion of hylomorphisms, a general recursion pattern, to make it possible to reason about both the functional correctness properties and the extra-functional timing properties of structured parallel programs. We have previously used hylomorphisms to provide a denotational semantics for skeletons, and proved that a given parallel structure for a program satisfies functional correctness. This paper expands on this theme, providing a simple operational semantics for algorithmic skeletons and a cost semantics that can be automatically derived from that operational semantics. We prove that both semantics are sound with respect to our previously defined denotational semantics. This means that we can now automatically and statically choose a provably optimal parallel structure for a given program with respect to a cost model for a (class of) parallel architecture. By deriving an automatic amortised analysis from our cost model, we can also accurately predict parallel runtimes and speedups.

show abstract

A language-independent parallel refactoring framework

Cited by 10 publications

References 13 publications

A survey of concurrency-oriented refactoring

A survey of concurrency-oriented refactoring

Type-Driven Development of Concurrent Communicating Systems

Automatically deriving cost models for structured parallel processes using hylomorphisms

Contact Info

Product

Resources

About