With-Loop Scalarization – Merging Nested Array Operations

Grelck, Clemens; Scholz, Sven-Bodo; Trojahner, Kai

doi:10.1007/978-3-540-27861-0_8

Cited by 15 publications

(14 citation statements)

References 20 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…Over recent years we have developed several analysis and program transformation techniques that aim at identifying these properties. Amongst these are partial evaluation techniques such as those described in [36,59,10,39], as well as code restructuring techniques [56,34,37], and multi-threaded code generation techniques [33,35]. However, the interplay of such optimisations combined with the complexity and variety of target platforms often renders static mapping approaches far less effective than the mappings that can easily be achieved manually.…”

Section: Related Workmentioning

confidence: 99%

The ParaPhrase Project: Parallel Patterns for Adaptive Heterogeneous Multicore Systems

Hammond

Aldinucci²,

Brown

et al. 2013

Formal Methods for Components and Objects

View full text Add to dashboard Cite

Abstract. This paper describes the ParaPhrase project, a new 3-year targeted research project funded under EU Framework 7 Objective 3.4 (Computer Systems), starting in October 2011. ParaPhrase aims to follow a new approach to introducing parallelism using advanced refactoring techniques coupled with high-level parallel design patterns. The refactoring approach will use these design patterns to restructure programs defined as networks of software components into other forms that are more suited to parallel execution. The programmer will be aided by high-level cost information that will be integrated into the refactoring tools. The implementation of these patterns will then use a wellunderstood algorithmic skeleton approach to achieve good parallelism.A key ParaPhrase design goal is that parallel components are intended to match heterogeneous architectures, defined in terms of CPU/GPU combinations, for example. In order to achieve this, the ParaPhrase approach will map components at link time to the available hardware, and will then re-map them during program execution, taking account of multiple applications, changes in hardware resource availability, the desire to reduce communication costs etc. In this way, we aim to develop a new approach to programming that will be able to produce software that can adapt to dynamic changes in the system environment. Moreover, by using a strong component basis for parallelism, we can achieve potentially significant gains in terms of reducing sharing at a high level of abstraction, and so in reducing or even eliminating the costs that are usually associated with cache management, locking, and synchronisation.

show abstract

Section: Related Workmentioning

confidence: 99%

The ParaPhrase Project: Parallel Patterns for Adaptive Heterogeneous Multicore Systems

Hammond

Aldinucci²,

Brown

et al. 2013

Formal Methods for Components and Objects

View full text Add to dashboard Cite

show abstract

“…StagedSAC on the other hand is embedded in Scala using the Delite framework and generates Scala code, which is later translated to JVM bytecode. Furthermore the set of optimizations in the two compilers are very different: some optimizations are only available in StagedSAC, as we will discuss in Section 5 while others [14,15,23] are only available in SAC. We are currently working on implementing more optimizations in StagedSAC by extending the Delite framework to support them in a generic fashion.…”

Section: Related Workmentioning

confidence: 99%

StagedSAC

Ureche

Rompf

Sujeeth

et al. 2012

Proceedings of the ACM SIGPLAN 2012 Workshop on Partial Evaluation and Program Manipulation

View full text Add to dashboard Cite

Domain-specific languages (DSLs) can bridge the gap between high-level programming and efficient execution. However, implementing compiler tool-chains for performance oriented DSLs requires significant effort. Recent research has produced methodologies and frameworks that promise to reduce this development effort by enabling quick transition from library-only, purely embedded DSLs to optimizing compilation.In this case study we report on our experience implementing a compiler for StagedSAC. StagedSAC is a DSL for arithmetic processing with multidimensional arrays modeled after the stand-alone language SAC (Single Assignment C). The main language feature of both SAC and StagedSAC is a loop construction that enables high-level and concise implementations of array algorithms. At the same time, the functional semantics of the two languages allow for advanced compiler optimizations and parallel code generation.We describe how we were able to quickly evolve from a pure library DSL to a performance-oriented compiler with a good speedup and only minor syntax changes using the technique of Lightweight Modular Staging. We also describe the optimizations we perform to obtain fast code and how we plan to generate parallel code with minimal effort using the Delite framework.

show abstract

“…As a simple example, consider the WITH-loop It should be mentioned here, that these WITH-loops constitute a restricted form of the WITH-loops in SAC. Exact definitions of fully-fledged WITH-loops and the formal definitions of transformations on them can be found elsewhere [12,11,10].…”

Section: With-loops In Sacmentioning

confidence: 99%

“…Under certain circumstances such nestings can be combined into single WITH-loops that operate one scalar values eliminating all micro-synchronizations that would result from a naive compilation otherwise. A transformation scheme to this effect is WITH-loopscalarization [10].…”

Section: Introductionmentioning

confidence: 99%

Merging compositions of array skeletons in SaC

Grelck

Scholz

2006

Parallel Computing

Self Cite

View full text Add to dashboard Cite

In the array language SAC, implicitly parallel array skeletons can be defined from meta-skeletons that are part of the language itself. This offers a high potential for code reuse as well as for high-level program specifications. However, the downside of introducing parallelism on the level of relatively simple application building blocks is limited runtime performance due to a generally poor ratio between productive computation on the one side and communication and synchronization on the other side. To overcome this limitation we have developed compiler optimizations that identify different composition scenarios of skeletons each of which is addressed by a specific code transformation technique that merges individual skeletons into a single more powerful one. This paper demonstrates how these transformations can be combined to systematically restructure compositions of skeletons into more complex skeletons that, in turn, can be compiled into efficiently executable parallel code.

show abstract

With-Loop Scalarization – Merging Nested Array Operations

Cited by 15 publications

References 20 publications

The ParaPhrase Project: Parallel Patterns for Adaptive Heterogeneous Multicore Systems

The ParaPhrase Project: Parallel Patterns for Adaptive Heterogeneous Multicore Systems

StagedSAC

Merging compositions of array skeletons in SaC

Contact Info

Product

Resources

About