Implementing the conjugate gradient algorithm in a functional language

Serrarens, Pascal R.

doi:10.1007/3-540-63237-9_22

Cited by 5 publications

(4 citation statements)

References 10 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…The use of overloading has the advantage that we can store elements unboxed in these arrays, which in turn improves performance significantly (cf. [33] for a benchmark). In fact, this overloading-based approach to unboxed arrays was inspired by the Haskell libraries of GHC [36], which in turn follow the Clean array library [16].…”

Section: Basic Arraysmentioning

confidence: 99%

“…Flattened array algorithms are combinator-based and generate many intermediate structures. In fact, they are rather far away from what previous work identified as being efficient formulations of array algorithms in general-purpose functional languages: They should be based on unboxed and updatable arrays [16,33]. An unboxed array stores the binary representation of an element (e.g., an integer number) directly, whereas a boxed array would store a pointer to a heap-allocated cell containing the integer value.…”

Section: Introductionmentioning

confidence: 99%

“…Serrarens [33] clearly demonstrates the performance difference between a straight-forward implementation of an array algorithm using lazy arrays and an optimised version based on unboxed and updatable arrays. He performs the transformation of the straight-forward into the optimised implementation manually.…”

Section: Introductionmentioning

confidence: 99%

See 2 more Smart Citations

Functional array fusion

Chakravarty¹,

Keller²

2001

Proceedings of the Sixth ACM SIGPLAN International Conference on Functional Programming - ICFP '01

View full text Add to dashboard Cite

This paper introduces a new approach to optimising array algorithms in functional languages. We are specifically aiming at an efficient implementation of irregular array algorithms that are hard to implement in conventional array languages such as Fortran. We optimise the storage layout of arrays containing complex data structures and reduce the running time of functions operating on these arrays by means of equational program transformations. In particular, this paper discusses a novel form of combinator loop fusion, which by removing intermediate structures optimises the use of the memory hierarchy.We identify a combinator named loopP that provides a general scheme for iterating over an array and that in conjunction with an array constructor replicateP is sufficient to express a wide range of array algorithms. On this basis, we define equational transformation rules that combine traversals of loopP and replicateP as well as sequences of applications of loopP into a single loopP traversal.Our approach naturally generalises to a parallel implementation and includes facilities for optimising load balancing and communication. A prototype implementation based on the rewrite rule pragma of the Glasgow Haskell Compiler is significantly faster than standard Haskell arrays and approaches the speed of hand coded C for simple examples.

show abstract

Section: Basic Arraysmentioning

confidence: 99%

Section: Introductionmentioning

confidence: 99%

See 1 more Smart Citation

Functional array fusion

Chakravarty¹,

Keller²

2001

Proceedings of the Sixth ACM SIGPLAN International Conference on Functional Programming - ICFP '01

View full text Add to dashboard Cite

show abstract

“…Investigations involving Clean and Haskell have shown that arrays need to be strict and unboxed in order to achieve acceptable runtime performance (van Groningen, 1997;Serrarens, 1997;Zörner, 1998;Chakravarty & Keller, 2003). Furthermore, array processing must be organized in a single-threaded manner, based on uniqueness types (Barendsen & Smetsers, 1995) or on state monads (Wadler, 1992).…”

Section: Introductionmentioning

confidence: 99%

Shared memory multiprocessor support for functional array processing in SAC

Grelck¹

2005

J. Funct. Prog.

View full text Add to dashboard Cite

Classical application domains of parallel computing are dominated by processing large arrays of numerical data. Whereas most functional languages focus on lists and trees rather than on arrays, SAC is tailor-made in design and in implementation for efficient high-level array processing. Advanced compiler optimizations yield performance levels that are often competitive with low-level imperative implementations. Based on SAC, we develop compilation techniques and runtime system support for the compiler-directed parallel execution of high-level functional array processing code on shared memory architectures. Competitive sequential performance gives us the opportunity to exploit the conceptual advantages of the functional paradigm for achieving real performance gains with respect to existing imperative implementations, not only in comparison with uniprocessor runtimes. While the design of SAC facilitates parallelization, the particular challenge of high sequential performance is that realization of satisfying speedups through parallelization becomes substantially more difficult. We present an initial compilation scheme and multi-threaded execution model, which we step-wise refine to reduce organizational overhead and to improve parallel performance. We close with a detailed analysis of the impact of certain design decisions on runtime performance, based on a series of experiments.

show abstract