A calculational approach to flattening nested data parallelism in functional languages

Concurrency and Parallelism, Programming, Networking, and Security - Lecture Notes in Computer Science ◽

10.1007/bfb0027796 ◽

1996 ◽

pp. 234-243 ◽

Cited By ~ 6

Author(s):

Gabriele Keller ◽

Martin Simons

Keyword(s):

Data Parallelism ◽

Functional Languages ◽

Nested Data

Download Full-text

Incremental flattening for nested data parallelism

Proceedings of the 24th Symposium on Principles and Practice of Parallel Programming ◽

10.1145/3293883.3295707 ◽

2019 ◽

Cited By ~ 3

Author(s):

Troels Henriksen ◽

Frederik Thorøe ◽

Martin Elsman ◽

Cosmin Oancea

Keyword(s):

Data Parallelism ◽

Nested Data

Download Full-text

Lazy tree splitting

Journal of Functional Programming ◽

10.1017/s0956796812000172 ◽

2012 ◽

Vol 22 (4-5) ◽

pp. 382-438 ◽

Cited By ~ 5

Author(s):

LARS BERGSTROM ◽

MATTHEW FLUET ◽

MIKE RAINEY ◽

JOHN REPPY ◽

ADAM SHAW

Keyword(s):

Experimental Data ◽

Binary Trees ◽

Parallel Applications ◽

Data Parallelism ◽

Present Experimental Data ◽

Nested Data ◽

Parallel Decomposition ◽

Binary Splitting ◽

Parallel Loops ◽

Parallel Arrays

AbstractNested data-parallelism (NDP) is a language mechanism that supports programming irregular parallel applications in a declarative style. In this paper, we describe the implementation of NDP in Parallel ML (PML), which is a part of the Manticore system. One of the main challenges of implementing NDP is managing the parallel decomposition of work. If we have too many small chunks of work, the overhead will be too high, but if we do not have enough chunks of work, processors will be idle. Recently, the technique of Lazy Binary Splitting was proposed to address this problem for nested parallel loops over flat arrays. We have adapted this technique to our implementation of NDP, which uses binary trees to represent parallel arrays. This new technique, which we call Lazy Tree Splitting (LTS), has the key advantage of performance robustness, i.e., it does not require tuning to get the best performance for each program. We describe the implementation of the standard NDP operations using LTS and present experimental data that demonstrate the scalability of LTS across a range of benchmarks.

Download Full-text