Implementing the NAS benchmark MG in SAC

Grelck, Clemens

doi:10.1109/ipdps.2002.1016488

Cited by 7 publications

(8 citation statements)

References 17 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…Several case studies have shown that simple recompilation of SaC code yields speedups that are competitive with manually parallelized imperative programs. High sequential performance allows implicitly parallelized SaC code to substantially outperform even hand-optimized sequential imperative programs Grelck, 2002;Grelck & Scholz, 2003b;Grelck & Scholz, 2003a).…”

Section: Resultsmentioning

confidence: 99%

“…In order to quantify the impact of individual design decisions on the parallel performance of compiled SaC code we restrict ourselves to a set of representative micro benchmarks. Readers looking for more general case studies on programming methodology and runtime performance in comparison with other programming environments are referred elsewhere Grelck, 2002;Grelck & Scholz, 2003b;Grelck & Scholz, 2003a). Experiments have been made on three different machine architectures: a 4-processor SUN E650, a 12processor SUN E4000, and a 72-processor SUN E15k.…”

Section: Experimental Evaluationmentioning

confidence: 99%

“…Despite the high-level Apl-like programming style, SaC code has managed to outperform equivalent Sisal programs . In several case studies SaC has also proved to be competitive even with low-level, machine-oriented languages Grelck, 2002;Grelck & Scholz, 2003b;Scholz, 2003;Grelck & Scholz, 2003a). We achieve this runtime behaviour by the consequent application of standard compiler optimizations in conjunction with a number of tailor-made array optimizations.…”

Section: Introductionmentioning

confidence: 96%

See 2 more Smart Citations

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

Section: Resultsmentioning

confidence: 99%

Section: Experimental Evaluationmentioning

confidence: 99%

Section: Introductionmentioning

confidence: 96%

See 1 more Smart Citation

Shared memory multiprocessor support for functional array processing in SAC

Grelck¹

2005

J. Funct. Prog.

View full text Add to dashboard Cite

show abstract

“…Where this separation does not prevail, for example in high‐performance computing, often applications internally apply the same functions to arguments of different shape in a way that is difficult to deduce statically even if the initial shapes are indeed known. Examples here are the NAS benchmarks MG and FT .…”

Section: Experimental Evaluationmentioning

confidence: 99%

Asynchronous adaptive optimisation for generic data‐parallel array programming

Grelck

Deurzen

Herhut

et al. 2011

Concurrency and Computation

View full text Add to dashboard Cite

SUMMARYProgramming productivity very much depends on the availability of basic building blocks that can be reused for a wide range of application scenarios and the ability to define rich abstraction hierarchies. Driven by the aim for increased reuse, such basic building blocks tend to become more and more generic in their specification; structural as well as behavioural properties are turned into parameters that are passed on to lower layers of abstraction where eventually a differentiation is being made. In the context of array programming, such properties are typically array ranks (number of axes/dimensions) and array shapes (number of elements along each axis/dimension). This allows for abstract definitions of operations such as element-wise additions, concatenations, rotations, and so on, which jointly enable a very high-level compositional style of programming, similar to, for instance, MATLAB. However, such a generic programming style generally comes at a price in terms of runtime overheads when compared against tailor-made low-level implementations. Additional layers of abstraction as well as the lack of hard-coded structural properties often inhibits optimisations that are obvious otherwise. Although complex static compiler analyses and transformations such as partial evaluations can ameliorate the situation to quite some extent, there are cases, where the required level of information is not available until runtime. In this paper, we propose to shift part of the optimisation process into the runtime of applications. Triggered by some runtime observation, the compiler asynchronously applies partial evaluation techniques to frequently used program parts and dynamically replaces initial program fragments by more specialised ones through dynamic relinking. In contrast to many existing approaches, we suggest this optimisation to be done in a rather non-intrusive, decoupled way. We use a full-fledged compiler that is run on a separate core. This measure enables us to run the compiler on its highest optimisation-level, which requires non-negligible compilation times for our optimisations. We use the compiler's type system to identify the potential dynamic optimisations. And we use the host language's module system as a facilitator for the dynamic code modifications. We present the architecture and implementation of an adaptive compilation framework for Single Assignment C, a data-parallel array programming language. Single Assignment C advocates shape-generic and rank-generic programming with arrays. A sophisticated, highly optimising compiler technology nevertheless achieves competitive runtime performance. We demonstrate the suitability of our approach to achieve consistently high performance independent of the static availability of array properties by means of several experiments based on a highly generic formulation of rank-invariant convolution as a case study.

show abstract

“…For certain applications, predominantly numerical applications on large homogeneous data structures, these languages can deliver parallel performance competitive if not superior to that of hand-coded Fortran programs [2,4,7,9]. The beauty of this approach is that it is completely implicit and thus avoids all the usual pitfalls of concurrent programming such as deadlocks or race conditions.…”

Section: Introductionmentioning

confidence: 99%

Coordinating Data Parallel SAC Programs with S-Net

Grelck¹,

Scholz²,

Shafarenko³

2007

2007 IEEE International Parallel and Distributed Processing Symposium

View full text Add to dashboard Cite

We propose a two-layered approach for exploiting different forms of concurrency in complex systems: We specify computational components in our functional array language SaC, which exploits data parallel properties of array processing code. The declarative stream processing language S-Net is used to orchestrate the collaborative behaviour of these components in a streaming network. We illustrate our approach by a hybrid implementation of a sudoku puzzle solver as a representative for more complex search problems.

show abstract

Implementing the NAS benchmark MG in SAC

Cited by 7 publications

References 17 publications

Shared memory multiprocessor support for functional array processing in SAC

Shared memory multiprocessor support for functional array processing in SAC

Asynchronous adaptive optimisation for generic data‐parallel array programming

Coordinating Data Parallel SAC Programs with S-Net

Contact Info

Product

Resources

About