Q'Nial: a portable interpreter for the nested interactive array language, Nial
Software—Practice & Experience
The C programming language
Retire Fortran?: a debate rekindled
Communications of the ACM
The annotated ANSI C Standard American National Standard for Programming Languages—C: ANSI/ISO 9899-1990
The role of APL and J in high-performance computation
APL '93 Proceedings of the international conference on APL
Implementation of a portable nested data-parallel language
Journal of Parallel and Distributed Computing - Special issue on data parallel algorithms and programming
Using MPI: portable parallel programming with the message-passing interface
Using MPI: portable parallel programming with the message-passing interface
Lisp and Symbolic Computation - Special issue on state in programming languages (part I)
Garbage collection: algorithms for automatic dynamic memory management
Garbage collection: algorithms for automatic dynamic memory management
The aggregate update problem in functional programming systems
POPL '85 Proceedings of the 12th ACM SIGACT-SIGPLAN symposium on Principles of programming languages
A method for overlapping and erasure of lists
Communications of the ACM
OpenMP: An Industry-Standard API for Shared-Memory Programming
IEEE Computational Science & Engineering
Sassy: A Language and Optimizing Compiler for Image Processing on Reconfigurable Computing Systems
ICVS '99 Proceedings of the First International Conference on Computer Vision Systems
Implementing the NAS Benchmark MG in SAC
IPDPS '02 Proceedings of the 16th International Parallel and Distributed Processing Symposium
Uniprocessor Garbage Collection Techniques
IWMM '92 Proceedings of the International Workshop on Memory Management
The Implementation and Efficiency of Arrays in Clean 1.1
IFL '96 Selected Papers from the 8th International Workshop on Implementation of Functional Languages
WITH-Loop-Folding in SAC - Condensing Consecutive Array Operations
IFL '97 Selected Papers from the 9th International Workshop on Implementation of Functional Languages
On Code Generation for Multi-generator WITH-Loops in SAC
IFL '99 Selected Papers from the 11th International Workshop on Implementation of Functional Languages
Improving Cache Effectiveness through Array Data Layout Manipulation in SAC
IFL '00 Selected Papers from the 12th International Workshop on Implementation of Functional Languages
Single Assignment C: efficient support for high-level array operations in a functional setting
Journal of Functional Programming
Shared memory multiprocessor support for functional array processing in SAC
Journal of Functional Programming
A programming language
SAC: a functional array language for efficient multi-threaded execution
International Journal of Parallel Programming
Merging compositions of array skeletons in SAC
Parallel Computing - Algorithmic skeletons
SAC: off-the-shelf support for data-parallelism on multicores
Proceedings of the 2007 workshop on Declarative aspects of multicore programming
Using OpenMP: Portable Shared Memory Parallel Programming (Scientific and Engineering Computation)
Using OpenMP: Portable Shared Memory Parallel Programming (Scientific and Engineering Computation)
Parallel generational-copying garbage collection with a block-structured heap
Proceedings of the 7th international symposium on Memory management
Controlling chaos: on safe side-effects in data-parallel operations
Proceedings of the 4th workshop on Declarative aspects of multicore programming
Implementation and evaluation of a microthread architecture
Journal of Systems Architecture: the EUROMICRO Journal
Numerical Simulations of Unsteady Shock Wave Interactions Using SaC and Fortran-90
PaCT '09 Proceedings of the 10th International Conference on Parallel Computing Technologies
IBM Journal of Research and Development
IFL'02 Proceedings of the 14th international conference on Implementation of functional languages
Index vector elimination: making index vectors affordable
IFL'06 Proceedings of the 18th international conference on Implementation and application of functional languages
Programming Massively Parallel Processors: A Hands-on Approach
Programming Massively Parallel Processors: A Hands-on Approach
Breaking the GPU programming barrier with the auto-parallelising SAC compiler
Proceedings of the sixth workshop on Declarative aspects of multicore programming
The NumPy Array: A Structure for Efficient Numerical Computation
Computing in Science and Engineering
Numerical Python for scalable architectures
Proceedings of the Fourth Conference on Partitioned Global Address Space Programming Model
Concurrent non-deferred reference counting on the Microgrid: first experiences
IFL'10 Proceedings of the 22nd international conference on Implementation and application of functional languages
With-Loop scalarization – merging nested array operations
IFL'03 Proceedings of the 15th international conference on Implementation of Functional Languages
IFL'05 Proceedings of the 17th international conference on Implementation and Application of Functional Languages
With-Loop fusion for data locality and parallelism
IFL'05 Proceedings of the 17th international conference on Implementation and Application of Functional Languages
Asynchronous adaptive optimisation for generic data-parallel array programming
Concurrency and Computation: Practice & Experience
Hi-index | 0.00 |
We present the ins and outs of the purely functional, data parallel programming language SaC (Single Assignment C). SaC defines state- and side-effect-free semantics on top of a syntax resembling that of imperative languages like C/C++/C# or Java: functional programming with curly brackets. In contrast to other functional languages data aggregation in SaC is not based on lists and trees, but puts stateless arrays into the focus. SaC implements an abstract calculus of truly multidimensional arrays that is adopted from interpreted array languages like Apl. Arrays are abstract values with certain structural properties. They are treated in a holistic way, not as loose collections of data cells or indexed memory address ranges. Programs can and should be written in a mostly index-free style. Functions consume array values as arguments and produce array values as results. The array type system of SaC allows such functions to abstract not only from the size of vectors or matrices but likewise from the number of array dimensions, supporting a highly generic programming style. The design of SaC aims at reconciling high productivity in software engineering of compute-intensive applications with high performance in program execution on modern multi- and many-core computing systems. While SaC competes with other functional and declarative languages on the productivity aspect, it competes with hand-parallelised C and Fortran code on the performance aspect. We achieve our goal through stringent co-design of programming language and compilation technology. The focus on arrays in general and the abstract view of arrays in particular combined with a functional state-free semantics are key ingredients in the design of SaC. In conjunction they allow for far-reaching program transformations and fully compiler-directed parallelisation. From literally the same source code SaC currently supports symmetric multi-socket, multi-core, hyperthreaded server systems, CUDA-enables graphics accelerators and the MicroGrid, an innovative general-purpose many-core architecture. The CEFP lecture provides an introduction into the language design of SaC, followed by an illustration of how these concepts can be harnessed to write highly abstract, reusable and elegant code. We conclude with outlining the major compiler technologies for achieving runtime performance levels that are competitive with low-level machine-oriented programming environments.