Parallel solutions of simple indexed recurrence equations

Ben-Asher, Yosi; Haber, Gadi

doi:10.1109/71.899937

“…This derived homomorphism is actually incorrect, because mps [1, −2, 2, 1] should be 2, but mps [1, −2] mps [2,1] gives 3. The problem in this derivation is in its wrong application of Theorem 3.3; it did not check whether the function can be written by both leftwards and rightwards functions, which is required by the theorem.…”

Section: Theorem 33 (Parallelization With Weak Right Inverse) If Fumentioning

confidence: 89%

“…The research on parallelization via derivation of list homomorphisms has gained great interest, and there have been many approaches, such as the third homomorphism theorem based method [15,19], function composition based method [14], matrix multiplication based method [31] and recurrence equation based method [2]. Our approach is unique in its use of weak right inverse in derivation of parallel programs.…”

Section: Derivation Of List Homomorphismmentioning

confidence: 97%

Automatic inversion generates divide-and-conquer parallel programs

MoritaKazutaka¹,

Morihata²,

et al. 2007

View full text Add to dashboard Cite

Divide-and-conquer algorithms are suitable for modern parallel machines, tending to have large amounts of inherent parallelism and working well with caches and deep memory hierarchies. Among others, list homomorphisms are a class of recursive functions on lists, which match very well with the divide-and-conquer paradigm. However, direct programming with list homomorphisms is a challenge for many programmers. In this paper, we propose and implement a novel system that can automatically derive costoptimal list homomorphisms from a pair of sequential programs, based on the third homomorphism theorem. Our idea is to reduce extraction of list homomorphisms to derivation of weak right inverses. We show that a weak right inverse always exists and can be automatically generated from a wide class of sequential programs. We demonstrate our system with several nontrivial examples, including the maximum prefix sum problem, the prefix sum computation, the maximum segment sum problem, and the line-ofsight problem. The experimental results show practical efficiency of our automatic parallelization algorithm and good speedups of the generated parallel programs.

show abstract

“…which would return the incorrect result if partial results for the two sequences [5,1,2,7], where m is 1 and m2 is 2, and [3,8,4,9], where m is 3 and m2 is 4 were to be combined. Using a template which is based on the code of the loop body with unknowns (aka syntax-guided synthesis), we synthesize the correct join in 5s (more on this example in Section 4).…”

Section: Overviewmentioning

confidence: 99%

“…Homomorphisms and Parallelism The closest category of papers to ours are the ones that use homomorphisms for parallelization. There has been previous attempts in using the derivation of list homomorphisms for parallelization, such as methods based on the third homomorphism theorem [16,18], those based on function composition [15], their less expressive/more practical variant based on matrix multiplication [43], methods based on the quantifier elimination [31] as well as those based on recurrence equations [8]. We will discuss the most closely related one here.…”

Section: Related Workmentioning

confidence: 99%

Synthesis of divide and conquer parallelism for loops

FarzanAzadeh¹,

2017

View full text Add to dashboard Cite

This paper focuses on automated synthesis of divide-andconquer parallelism, which is a common parallel programming skeleton supported by many cross-platform multithreaded libraries. The challenges of producing (manually or automatically) a correct divide-and-conquer parallel program from a given sequential code are two-fold: (1) assuming that individual worker threads execute a code identical to the sequential code, the programmer has to provide the extra code for dividing the tasks and combining the computation results, and (2) sometimes, the sequential code may not be usable as is, and may need to be modified by the programmer. We address both challenges in this paper. We present an automated synthesis technique for the case where no modifications to the sequential code are required, and we propose an algorithm for modifying the sequential code to make it suitable for parallelization when some modification is necessary. The paper presents theoretical results for when this modification is efficiently possible, and experimental evaluation of the technique and the quality of the produced parallel programs.

show abstract

“…The research on parallelization via derivation of list homomorphisms has gained great interest, and there have been many approaches, such as the third homomorphism theorem based method [15,19], function composition based method [14], matrix multiplication based method [31] and recurrence equation based method [2]. Our approach is unique in its use of weak right inverse in derivation of parallel programs.…”

Section: Derivation Of List Homomorphismmentioning

confidence: 99%

Automatic inversion generates divide-and-conquer parallel programs

Morita

¹

,

Morihata

²

,

Matsuzaki

³

et al. 2007

Proceedings of the 28th ACM SIGPLAN Conference on Programming Language Design and Implementation

View full text Add to dashboard Cite

Divide-and-conquer algorithms are suitable for modern parallel machines, tending to have large amounts of inherent parallelism and working well with caches and deep memory hierarchies. Among others, list homomorphisms are a class of recursive functions on lists, which match very well with the divide-and-conquer paradigm. However, direct programming with list homomorphisms is a challenge for many programmers. In this paper, we propose and implement a novel system that can automatically derive costoptimal list homomorphisms from a pair of sequential programs, based on the third homomorphism theorem. Our idea is to reduce extraction of list homomorphisms to derivation of weak right inverses. We show that a weak right inverse always exists and can be automatically generated from a wide class of sequential programs. We demonstrate our system with several nontrivial examples, including the maximum prefix sum problem, the prefix sum computation, the maximum segment sum problem, and the line-ofsight problem. The experimental results show practical efficiency of our automatic parallelization algorithm and good speedups of the generated parallel programs.

show abstract

Parallel solutions of simple indexed recurrence equations

Cited by 10 publications

References 7 publications

Automatic inversion generates divide-and-conquer parallel programs

Automatic inversion generates divide-and-conquer parallel programs

Synthesis of divide and conquer parallelism for loops

Automatic inversion generates divide-and-conquer parallel programs

Contact Info

Product

Resources

About