Results 1  10
of
10
Obsidian: A Domain Specific Embedded Language for GeneralPurpose Parallel Programming of Graphics Processors
 In Proc. of Implementation and Applications of Functional Languages (IFL), Lecture Notes in Computer Science
, 2008
"... Abstract. We present a domain specific language, embedded in Haskell, for general purpose parallel programming on GPUs. Our intention is to explore the use of connection patterns in parallel programming. We briefly present our earlier work on hardware generation, and outline the current state of GPU ..."
Abstract

Cited by 4 (1 self)
 Add to MetaCart
Abstract. We present a domain specific language, embedded in Haskell, for general purpose parallel programming on GPUs. Our intention is to explore the use of connection patterns in parallel programming. We briefly present our earlier work on hardware generation, and outline the current state of GPU architectures and programming models. Finally, we present the current status of the Obsidian project, which aims to make GPU programming easier, without relinquishing detailed control of GPU resources. Both a programming example and some details of the implementation are presented. This is a report on work in progress. 1
A Sound and Complete Abstraction for Reasoning about Parallel Prefix Sums ∗
"... Prefix sums are key building blocks in the implementation of many concurrent software applications, and recently much work has gone into efficiently implementing prefix sums to run on massively parallel graphics processing units (GPUs). Because they lie at the heart of many GPUaccelerated applicat ..."
Abstract

Cited by 1 (1 self)
 Add to MetaCart
(Show Context)
Prefix sums are key building blocks in the implementation of many concurrent software applications, and recently much work has gone into efficiently implementing prefix sums to run on massively parallel graphics processing units (GPUs). Because they lie at the heart of many GPUaccelerated applications, the correctness of prefix sum implementations is of prime importance. We introduce a novel abstraction, the interval of summations, that allows scalable reasoning about implementations of prefix sums. We present this abstraction as a monoid, and prove a soundness and completeness result showing that a generic sequential prefix sum implementation is correct for an array of length n if and only if it computes the correct result for a specific test case when instantiated with the interval of summations monoid. This allows correctness to be established by running a single test where the in
devant le jury composé de:
, 2006
"... dans l’école doctorale de Mathématiques, Sciences et Technologies de ..."
(Show Context)
Nonnumerical Algorithms and Problems; F.3.1 [Logics and Meanings of Programs]: Specifying and Verifying and Reasoning about Programs
"... This pearl develops a statement about parallel prefix computation in the spirit of Knuth’s 01Principle for oblivious sorting algorithms. It turns out that 01 is not quite enough here. The perfect hammer for the nails we are going to drive in is relational parametricity. ..."
Abstract
 Add to MetaCart
(Show Context)
This pearl develops a statement about parallel prefix computation in the spirit of Knuth’s 01Principle for oblivious sorting algorithms. It turns out that 01 is not quite enough here. The perfect hammer for the nails we are going to drive in is relational parametricity.
Folding DomainSpecific Languages: Deep and Shallow Embeddings (Functional Pearl)
"... A domainspecific language can be implemented by embedding within a generalpurpose host language. This embedding may be deep or shallow, depending on whether terms in the language construct syntactic or semantic representations. The deep and shallow styles are closely related, and intimately connec ..."
Abstract
 Add to MetaCart
(Show Context)
A domainspecific language can be implemented by embedding within a generalpurpose host language. This embedding may be deep or shallow, depending on whether terms in the language construct syntactic or semantic representations. The deep and shallow styles are closely related, and intimately connected to folds; in this paper, we explore that connection. 1.
Parallel Prefix Network Generation: an Application of Functional Programming
"... Parallel prefix networks are used in priority encoders, and to compute carries in fast adders. A typical microprocessor contains many such networks, and often they are hotspots. Although parallel prefix (or scan) has been much studied, surprisingly many questions remain unanswered. As geometries shr ..."
Abstract
 Add to MetaCart
(Show Context)
Parallel prefix networks are used in priority encoders, and to compute carries in fast adders. A typical microprocessor contains many such networks, and often they are hotspots. Although parallel prefix (or scan) has been much studied, surprisingly many questions remain unanswered. As geometries shrink, it is not at all clear how to make low power prefix networks with the desired timing properties. Here, I develop a method of writing very highly parameterised parallel prefix network generators in which we specify the combinators used to build the networks and then search for a topology that matches the given delay constraints. This first case study indicates that, in this functional setting, combinators and search fit well together. The resulting prefix networks are both small and shallow, and likely to be useful in low power applications. 1
Performance Analysis and Design Aids
"... We develop a Haskell library for functionallogic programming, motivated by the implementation of Wired, a relational embedded domainspecific language for describing and analysing digital circuits at the VLSIlayout level. Compared to a previous library for logic programming by Claessen and Ljunglö ..."
Abstract
 Add to MetaCart
(Show Context)
We develop a Haskell library for functionallogic programming, motivated by the implementation of Wired, a relational embedded domainspecific language for describing and analysing digital circuits at the VLSIlayout level. Compared to a previous library for logic programming by Claessen and Ljunglöf, we support residuation, easier creation of logical data types, and pattern matching. We discuss other applications of our library, including testdata generation, and various extensions, including lazy narrowing.
about Programs General Terms
"... This pearl develops a statement about parallel prefix computation in the spirit of Knuth’s 01Principle for oblivious sorting algorithms. It turns out that 01 is not quite enough here. The perfect hammer for the nails we are going to drive in is relational parametricity. Categories and Subject Des ..."
Abstract
 Add to MetaCart
(Show Context)
This pearl develops a statement about parallel prefix computation in the spirit of Knuth’s 01Principle for oblivious sorting algorithms. It turns out that 01 is not quite enough here. The perfect hammer for the nails we are going to drive in is relational parametricity. Categories and Subject Descriptors D.1.1 [Programming Techniques]: