An introduction to the theory of lists
Proceedings of the NATO Advanced Study Institute on Logic of programming and calculi of discrete design
A simple parallel tree contraction algorithm
Journal of Algorithms
Deforestation: transforming programs to eliminate trees
Proceedings of the Second European Symposium on Programming
FPCA '89 Proceedings of the fourth international conference on Functional programming languages and computer architecture
Algorithmic skeletons: structured management of parallel computation
Algorithmic skeletons: structured management of parallel computation
Implementation of a portable nested data-parallel language
Journal of Parallel and Distributed Computing - Special issue on data parallel algorithms and programming
Efficient parallel algorithms for tree accumulations
Science of Computer Programming
Ropes: an alternative to strings
Software—Practice & Experience
Shortcut deforestation in calculational form
FPCA '95 Proceedings of the seventh international conference on Functional programming languages and computer architecture
Deriving structural hylomorphisms from recursive definitions
Proceedings of the first ACM SIGPLAN international conference on Functional programming
Parallel implementation of tree skeletons
Journal of Parallel and Distributed Computing
A data structure for dynamically maintaining rooted trees
Journal of Algorithms
Tupling calculation eliminates multiple data traversals
ICFP '97 Proceedings of the second ACM SIGPLAN international conference on Functional programming
Parallelization in calculational forms
POPL '98 Proceedings of the 25th ACM SIGPLAN-SIGACT symposium on Principles of programming languages
The Parallel Evaluation of General Arithmetic Expressions
Journal of the ACM (JACM)
A Transformation System for Developing Recursive Programs
Journal of the ACM (JACM)
The Art of Computer Programming Volumes 1-3 Boxed Set
The Art of Computer Programming Volumes 1-3 Boxed Set
Synthesis of Parallel Algorithms
Synthesis of Parallel Algorithms
Concatenate, reverse and map vanish for free
Proceedings of the seventh ACM SIGPLAN international conference on Functional programming
An Accumulative Parallel Skeleton for All
ESOP '02 Proceedings of the 11th European Symposium on Programming Languages and Systems
Functional Programming with Bananas, Lenses, Envelopes and Barbed Wire
Proceedings of the 5th ACM Conference on Functional Programming Languages and Computer Architecture
Relating Accumulative and Non-accumulative Functional Programs
RTA '01 Proceedings of the 12th International Conference on Rewriting Techniques and Applications
Optimal Parallel Evaluation of Tree-Structured Computations by Raking
AWOC '88 Proceedings of the 3rd Aegean Workshop on Computing: VLSI Algorithms and Architectures
Parallelization via Context Preservatio
ICCL '98 Proceedings of the 1998 International Conference on Computer Languages
Dynamizing static algorithms, with applications to dynamic trees and history independence
SODA '04 Proceedings of the fifteenth annual ACM-SIAM symposium on Discrete algorithms
Towards automatic parallelization of tree reductions in dynamic programming
Proceedings of the eighteenth annual ACM symposium on Parallelism in algorithms and architectures
Parallel skeletons for manipulating general trees
Parallel Computing - Algorithmic skeletons
MapReduce: simplified data processing on large clusters
OSDI'04 Proceedings of the 6th conference on Symposium on Opearting Systems Design & Implementation - Volume 6
Much ado about two (pearl): a pearl on parallel prefix computation
Proceedings of the 35th annual ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Parallel tree contraction and its application
SFCS '85 Proceedings of the 26th Annual Symposium on Foundations of Computer Science
Implicitly-threaded parallelism in Manticore
Proceedings of the 13th ACM SIGPLAN international conference on Functional programming
Efficient Implementation of Tree Accumulations on Distributed-Memory Parallel Computers
ICCS '07 Proceedings of the 7th international conference on Computational Science, Part II
Bidirectionalization for free! (Pearl)
Proceedings of the 36th annual ACM SIGPLAN-SIGACT symposium on Principles of programming languages
The third homomorphism theorem on trees: downward & upward lead to divide-and-conquer
Proceedings of the 36th annual ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Regular, shape-polymorphic, parallel arrays in Haskell
Proceedings of the 15th ACM SIGPLAN international conference on Functional programming
Automatic parallelization of recursive functions using quantifier elimination
FLOPS'10 Proceedings of the 10th international conference on Functional and Logic Programming
Macro tree transformations of linear size increase achieve cost-optimal parallelism
APLAS'11 Proceedings of the 9th Asian conference on Programming Languages and Systems
Hi-index | 0.00 |
Divide-and-conquer is an important technique in parallel programming. However, algebraic data structures do not fit divide-and-conquer parallelism. For example, the usual pointer-based implementation of lists cannot efficiently be divided at their middle, which prevents us from developing list-iterating divide-and-conquer parallel programs. Tree-iterating programs possibly face a similar problem, because trees might be ill-balanced and list-like shapes. This paper examines parallel programming based on balanced trees: we consider balanced-tree structures and develop recursive functions on them. By virtue of their balancing nature, either bottom-up or top-down recursive functions exploit divide-and-conquer parallelism. Our main contribution is to demonstrate the promise of this approach. We propose a way of systematically developing balanced trees from parallel algorithms, and then, we show that efficient parallel programs on them can be developed by equational reasoning powered by Reynolds' relational parametricity. We consider functions that operate either lists or binary trees, and show that our methods can uniformly deal with both cases. The developed parallel programs are purely functional, correct by construction, and sometimes even simpler than known algorithms.