From Contracts Towards Dependent Types: Proofs by Partial Evaluation

Herhut, Stephan; Scholz, Sven-Bodo; Bernecky, Robert; Grelck, Clemens; Trojahner, Kai

doi:10.1007/978-3-540-85373-2_15

Cited by 5 publications

(5 citation statements)

References 15 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

“…These array types essentially form a hierarchy with three levels. On the lowest level, we find non-generic types that define arrays of fixed shape, for example int [3,7] or just int. On an intermediate level of genericity, we find arrays of fixed rank, for example int[.,.].…”

Section: Single Assignment C In a Nutshellmentioning

confidence: 99%

“…The hierarchy of array types induces a subtype relationship, and SAC supports function overloading with respect to subtyping. 42 rank: 3 shape: [2,2,3] data: [1,2,3,4,5,6,7,8,9,10,11,12] rank: 2 shape: [3,3] data: [1,2,3,4,5,6,7,8,9] rank: 1 shape: [ 6 ] data: [1,2,3,4,5,6] rank: 0 shape: [ ] data:…”

Section: Single Assignment C In a Nutshellmentioning

confidence: 99%

“…Their effectiveness, however, crucially depends on the level of static knowledge about the data involved. Even advanced symbolic analyses , although often successful, cannot fully eliminate this dependency. Ultimately, only radically specializing generic programs to actual input data guarantees sufficient static knowledge for a compiler to produce highly efficient code.…”

Section: Introductionmentioning

confidence: 99%

See 1 more Smart Citation

Asynchronous adaptive optimisation for generic data‐parallel array programming

Grelck

Deurzen

Herhut

et al. 2011

Concurrency and Computation

Self Cite

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

“…However, complete specification of all array types runs counter the software engineering desire for generic and abstract specifications and code reuse. Code specialization [7] and partial evaluation techniques [8] address this problem, but their success is program dependent. In general, dynamic consistency checks remain prevalent in compiled code.…”

Section: Introductionmentioning

confidence: 99%

Dependently typed array programs don’t go wrong

Trojahner¹,

Grelck²

2009

The Journal of Logic and Algebraic Programming

Self Cite

View full text Add to dashboard Cite

The array programming paradigm adopts multidimensional arrays as the fundamental data structures of computation. Array operations process entire arrays instead of just single elements. This makes array programs highly expressive and introduces data parallelism in a natural way. Array programming imposes non-trivial structural constraints on ranks, shapes, and element values of arrays. A prominent example where such constraints are violated are out-of-bound array accesses. Usually, such constraints are enforced by means of run time checks. Both the run time overhead inflicted by dynamic constraint checking and the uncertainty of proper program evaluation are undesirable. We propose a novel type system for array programs based on dependent types. Our type system makes dynamic constraint checks obsolete and guarantees orderly evaluation of well-typed programs. We employ integer vectors of statically unknown length to index array types. We also show how constraints on these vectors are resolved using a suitable reduction to integer scalars. Our presentation is based on a functional array calculus that captures the essence of the paradigm without the legacy and obfuscation of a fully-fledged array programming language.

show abstract

From Contracts Towards Dependent Types: Proofs by Partial Evaluation

Cited by 5 publications

References 15 publications

The ParaPhrase Project: Parallel Patterns for Adaptive Heterogeneous Multicore Systems

The ParaPhrase Project: Parallel Patterns for Adaptive Heterogeneous Multicore Systems

Asynchronous adaptive optimisation for generic data‐parallel array programming

Dependently typed array programs don’t go wrong

Contact Info

Product

Resources

About