Guiding parallel array fusion with indexed types

Lippmeier, Ben; Chakravarty, Manuel M. T.; Keller, Gabriele; Jones, Simon Peyton

doi:10.1145/2430532.2364511

Cited by 12 publications

(15 citation statements)

References 16 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…Single Assignment C [10] is a notable language with built-in n-array support. Other languages have wellestablished array libraries, like the C++ libraries Blitz++ [30] and Boost.MultiArray [9] and Haskell's Repa (Regular Parallel Arrays) [15,20,21]. These libraries leverage the static semantics of their host languages to define n-arrays inductively as the outer product of a 1-array with an (n 1)-array [1].…”

Section: Array Librariesmentioning

confidence: 99%

Array Operators Using Multiple Dispatch

Bezanson¹,

Chen²,

Karpinski³

et al. 2014

Proceedings of ACM SIGPLAN International Workshop on Libraries, Languages, and Compilers for Array Programming

View full text Add to dashboard Cite

Arrays are such a rich and fundamental data type that they tend to be built into a language, either in the compiler or in a large lowlevel library. Defining this functionality at the user level instead provides greater flexibility for application domains not envisioned by the language designer. Only a few languages, such as C++ and Haskell, provide the necessary power to define n-dimensional arrays, but these systems rely on compile-time abstraction, sacrificing some flexibility. In contrast, dynamic languages make it straightforward for the user to define any behavior they might want, but at the possible expense of performance.As part of the Julia language project, we have developed an approach that yields a novel trade-off between flexibility and compiletime analysis. The core abstraction we use is multiple dispatch. We have come to believe that while multiple dispatch has not been especially popular in most kinds of programming, technical computing is its killer application. By expressing key functions such as array indexing using multi-method signatures, a surprising range of behaviors can be obtained, in a way that is both relatively easy to write and amenable to compiler analysis. The compact factoring of concerns provided by these methods makes it easier for userdefined types to behave consistently with types in the standard library.

show abstract

Section: Array Librariesmentioning

confidence: 99%

Array Operators Using Multiple Dispatch

Bezanson¹,

Chen²,

Karpinski³

et al. 2014

Proceedings of ACM SIGPLAN International Workshop on Libraries, Languages, and Compilers for Array Programming

View full text Add to dashboard Cite

show abstract

“…It allows computation over highrank arrays to be expressed in a type-safe manner, and at the same time enables implicit parallel execution on multi-core CPUs with aggressive array fusion guided by indexed types [12]. Consider the following Repa program map2: In the above program, both a and b are two-dimensional arrays, where a is fully manifest (type-indexed by U), and b represents a 'delayed' computation (type-indexed by D) based on the input array a.…”

Section: Overview Of Repamentioning

confidence: 99%

“…This is often the case, but sometimes the situation is more complex than appears at first glance. To paraphrase an example given by Lippmeier, et al [12]:…”

Section: Strictnessmentioning

confidence: 99%

“…To alleviate this problem, Lippmeier, et al [12] suggest users "add bang patterns to all array parameters for functions using the Repa library", and use seq when bang patterns are not sufficient. This might come only as a minor annoyance in practice, but it is important to know the difference, especially when DSLs like Accelerate impose a strict semantics while Haskell and Repa do not.…”

Section: Strictnessmentioning

confidence: 99%

See 1 more Smart Citation

Native offload of Haskell repa programs to integrated GPUs

Liu

Day

Glew

et al. 2014

Proceedings of the 3rd ACM SIGPLAN Workshop on Functional High-Performance Computing

View full text Add to dashboard Cite

In light of recent hardware advances, general-purpose computing on graphics processing units (GPGPU) is becoming increasingly commonplace, and needs novel programming models due to GPUs' radically different architecture. For the most part, existing approaches to programming GPUs within a high-level programming language choose to embed a domain-specific language (DSL) within a host metalanguage and then implement a compiler that maps programs written within that DSL to code in low-level languages such as OpenCL or CUDA. An alternative, underexplored, approach is to compile a restricted subset of the host language itself directly down to OpenCL/CUDA. We believe more research should be done to compare these two approaches and their relative merits. As a step in this direction, we implemented a quick proof of concept of the alternative approach. Specifically, we extend the Repa library with a computeG function to offload a computation to the GPU. As long as the requested computation meets certain restrictions, we compile it to OpenCL 2.0 using the recently added feature for shared virtual memory. We can successfully run nine benchmarks on an Intel integrated GPU. We obtain the expected performance from the GPU on six of those benchmarks, and are close to the expected performance on two more. In this paper, we describe an offload primitive for Haskell, how to extend Repa to use it, how to implement that primitive in the Intel Labs Haskell Research Compiler, and evaluate the approach on nine benchmarks, comparing to two different CPUs, and for one benchmark to handwritten OpenCL code.

show abstract

“…The compiler must cope with boxed numeric types, handle lazy evaluation, and eliminate intermediate data structures. However, the Glasgow Haskell Compiler has become "sufficiently smart" that Haskell libraries for expressing numerical computations, such as Repa [17,21], no longer have to sacrifice speed at the altar of abstraction.…”

Section: Introductionmentioning

confidence: 99%

Exploiting vector instructions with generalized stream fusion

Mainland

Leshchinskiy²,

Jones

2013

Proceedings of the 18th ACM SIGPLAN International Conference on Functional Programming

Self Cite

View full text Add to dashboard Cite

Stream fusion [6] is a powerful technique for automatically transforming high-level sequence-processing functions into efficient implementations. It has been used to great effect in Haskell libraries for manipulating byte arrays, Unicode text, and unboxed vectors. However, some operations, like vector append, still do not perform well within the standard stream fusion framework. Others, like SIMD computation using the SSE and AVX instructions available on modern x86 chips, do not seem to fit in the framework at all.In this paper we introduce generalized stream fusion, which solves these issues. The key insight is to bundle together multiple stream representations, each tuned for a particular class of stream consumer. We also describe a stream representation suited for efficient computation with SSE instructions. Our ideas are implemented in modified versions of the GHC compiler and vector library. Benchmarks show that high-level Haskell code written using our compiler and libraries can produce code that is faster than both compiler-and hand-vectorized C.

show abstract

Guiding parallel array fusion with indexed types

Cited by 12 publications

References 16 publications

Array Operators Using Multiple Dispatch

Array Operators Using Multiple Dispatch

Native offload of Haskell repa programs to integrated GPUs

Exploiting vector instructions with generalized stream fusion

Contact Info

Product

Resources

About