Chapter

Uniqueness type inference

10/2006; DOI:10.1007/BFb0026821 pp.189-206
Source: DBLP

ABSTRACT We extend the Uniqueness Type System with uniqueness polymorphism. Using a notion of principal uniqueness variants the type system is shown to be effective in the sense that a uniqueness variant of a given conventional type can be determined automatically. The presented algorithm serves as a basis for type checking in the language Clean. We illustrate the system by some concrete examples.

0 0
 · 
0 Bookmarks
 · 
28 Views
  • Source
    Article: SAC: A Functional Array Language for Efficient Multithreaded Execution
    Clemens Grelck, Sven-Bodo Scholz
    [show abstract] [hide abstract]
    ABSTRACT: We give an in-depth introduction to the design of our functional array programming language SaC, the main aspects of its compilation into host machine code, and its parallelisation based on multi-threading. The language design of SaC aims at combining high-level, compositional array programming with fully automatic resource management for highly productive code development and maintenance. We outline the compilation process that maps SaC programs to computing machinery. Here, our focus is on optimisation techniques that aim at restructuring entire applications from nested compositions of general fine-grained operations into specialised coarse-grained operations. We present our implicit parallelisation technology for shared memory architectures based on multi-threading and discuss further optimisation opportunities on this level of code generation. Both optimisation and parallelisation rigorously exploit the absence of side-effects and the explicit data flow characteristic of a functional setting.
    International Journal of Parallel Programming 01/2006; 34(4):383-427. · 0.57 Impact Factor
  • Source
    Conference Proceeding: A modular memory optimization for synchronous data-flow languages: application to arrays in a lustre compiler
    Léonard Gérard, Adrien Guatto, Cédric Pasteur, Marc Pouzet
    [show abstract] [hide abstract]
    ABSTRACT: The generation of efficient sequential code for synchronous data-flow languages raises two intertwined issues: control and memory optimization. While the former has been extensively studied, for instance in the compilation of Lustre and Signal, the latter has only been addressed in a restricted manner. Yet, memory optimization becomes a pressing issue when arrays are added to such languages. This article presents a two-level solution to the memory optimization problem. It combines a compile-time optimization algorithm, reminiscent of register allocation, paired with language annotations on the source given by the designer. Annotations express in-place modifications and control where allocation is performed. Moreover, they allow external functions performing in-place modifications to be safely imported. Soundness of annotations is guaranteed by a semilinear type system and additional scheduling constraints. A key feature is that annotations for well-typed programs do not change the semantics of the language: removing them may lead to less efficient code but will not alter the semantics. The method has been implemented in a new compiler for a LUSTRE-like synchronous language extended with hierarchical automata and arrays. Experiments show that the proposed approach removes most of the unnecessary array copies, resulting in faster code that uses less memory.
    Proceedings of the 13th ACM SIGPLAN/SIGBED International Conference on Languages, Compilers, Tools and Theory for Embedded Systems, Beijing, China; 06/2012
Data provided are for informational purposes only. Although carefully collected, accuracy cannot be guaranteed. The impact factor represents a rough estimation of the journal's impact factor and does not reflect the actual current impact factor. Publisher conditions are provided by RoMEO. Differing provisions from the publisher's actual policy or licence agreement may be applicable.

Keywords

concrete examples
 
given conventional type
 
presented algorithm
 
type checking
 
type system
 
Uniqueness Type System