Just Testing

Lambda Science
About Me

I research and teach programming languages, compilers, and their applications at the University of New South Wales (UNSW), Sydney. My main interest is in functional and parallel programming, and in particular, in Haskell.


My Twitter handle is TacticalGrace.
Check out my UNSW website.

My Other Sites
TwitterLinkedInTumblrScribd
Tags
Archive
2012 (11)
2011 (5)
2010 (14)
2009 (43)
2008 (30)
2007 (23)
Filed under

gpgpu

See all posts on posterous with this tag »
 

GPU-accelerated array computations in Haskell

I just published stable release 0.12 of the embedded array language Accelerate for high-performance GPU computing on Hackage. The release includes example applications, such as a real-time Canny edge detector, a fluid flow simulator, and a quasicrystal animation, as well as example algorithms, such as radixsort, matrix computations, and a Black-Scholes option pricing model.

In the new modularised architecture, the Accelerate release comprises four packages:

  • accelerate (the main package providing the Accelerate language),
  • accelerate-io (conversion operations with other Haskell array libraries, including the data-parallel companion library Repa),
  • accelerate-cuda (backend targetting NVIDIA GPUs via the CUDA SDK), and
  • accelerate-examples (example applications and regression tests).

For more information, see Accelerate on GitHub. To use the CUDA backend, you need a CUDA-enabled NVIDIA GPU as well as having the CUDA SDK already installed.

Filed under  //  accelerate   gpgpu   haskell   parallelism  
Posted
 

GPU computing in Haskell: version 0.10 of Data.Array.Accelerate

Accelerate is an embedded language for GPU-accelerated array computations in Haskell that targets NVIDIA's CUDA framework and also has an experimental OpenCL backend (that currently does not support the whole feature set of the language). I just released version 0.10.0.0 of Accelerate. A considerable amount of example code is in the companion package accelerate-examples. The main user-visible changes in this release are frontend bug fixes.

For more information, have a look at Accelerate on GitHub.

Filed under  //  accelerate   gpgpu   haskell  
Posted
 

Released Data.Array.Accelerate 0.9.0.0 — the Haskell array library for GPUs

I just released accelerate 0.9.0.0 on Hackage. This is the version that has been available from the GitHub repository for a while (supporting shape polymorphism, stencil computations, block I/O, and much more), but adapted such that it works with the forthcoming GHC 7.4.1 release. (I tested it with 7.4.1 RC2).

It doesn't yet include Trevor's recent work that improved the CUDA backend in many significant ways — you can get that code from Trevor's fork on GitHub.

For more details, see the main GitHub repository and the GitHub wiki pages.

Filed under  //  accelerate   edsl   gpgpu   parallelism  
Posted
 

Data.Array.Accelerate now on GitHub

Prompted by GHC's move to Git and the unreliability of the community.haskell.org infrastructure, I decided to move Data.Array.Accelerate to GitHub: mchakravarty/accelerate. The GitHub repository is now the main public repository for the project. I will also move the tickets of the old Trac bug tracker over to GitHub Issues.

Filed under  //  edsl   gpgpu   haskell   parallelism  
Posted
 

Final version of the Accelerate paper (GPGPU in Haskell)

We will present our paper Accelerating Haskell Array Codes with Multicore GPUs at ACM SIGLAN Declarative Aspects of Multicore Programming (DAMP 2011), which is co-located with POPL'11 in Austin, TX, in January. The final version of our paper is now available, and we plan to soon release a significantly improved version of the Accelerate library (matching the API used in the paper), which enables high-level GPGPU programming in Haskell based on NVIDIA's CUDA environment.

Filed under  //  edsl   gpgpu   haskell   parallelism  
Posted
 

Accelerating Haskell Array Codes with Multicore GPUs

In the paper Accelerating Haskell Array Codes with Multicore GPUs, we describe Accelerate, embedded language for array computations in Haskell, as well as a dynamic code generator targeting NVIDIA's CUDA GPGPU programming environment.  Our CUDA code generator is based on the idea of algorithmic skeletons for parallel programming, minimises re-compilation overheads, and overlaps host-to-device data transfers, code generation, and kernel execution.

The paper outlines our embedding in Haskell, details the design and implementation of the dynamic code generator, and reports on initial benchmark results.  These results indicate that we can compete with moderately optimised native CUDA code, while enabling much simpler source programs.

Filed under  //  edsl   gpgpu   haskell   parallelism  
Posted
 

Second beta release for the CUDA backend of Accelerate

The second beta release of Data.Array.Accelerate (version 0.8.0.0) includes support for all array operations in the CUDA backend — except for a new stencil operation that is new in this release and currently only supported by the interpreter.  The CUDA backend requires CUDA 3.x and has been tested on consumer-grade GeForce cards, TESLA high-performance GPUs, and the new Fermi cards.

If you are interested in general-purpose GPU programming in Haskell, give this release a spin — it is available on Hackage.  While it is far from perfect, it should already prove useful for a considerable range of applications.  Together with the other Accelerate developers, I would be very interested to hear what works for you and what doesn't.  We are also interested in suggestions for the future development of the library.  Accelerate has a mailing list and a bug tracker on which we also accept feature requests.

Filed under  //  edsl   gpgpu   haskell   parallelism  
Posted
 

First release of the CUDA backend for Accelerate

During the first Australian Haskell Hackathon, AusHac2010, we finally managed to complete the integration of the CUDA backend, written by Sean Lee and Trevor McDonell, into the array EDSL Accelerate.  It still doesn't cover the complete functionality of the current version of the Accelerate EDSL, but already allows for interesting GPU computations.  The package source (version 0.7.1.0) can be obtained from Hackage as usual.  There is now also a bug tracker.

Filed under  //  edsl   gpgpu   haskell   parallelism  
Posted
 

NVIDIA’s next generation GPU architecture has a lot for HPC to love

Yesterday, NVIDIA presented its next-generation GPU architecture, called "Fermi": http://insidehpc.com/2009/09/30/nvidia-next-generation-gpu-fermi-targets-hpc-...

In addition to more raw computing power, Fermi brings advances that make it even more interesting for general-purpose computations than the current NVIDIA GPUs. In particular, it seems to support function pointers —at least they claim support for virtual functions— and improved support for double-precision floating-point numbers as well as coarse-grained MIMD support in the form of "concurrent kernel execution".

Filed under  //  accelerate   fermi   gpgpu  
Posted
 

Running Haskell Array Computations on a GPU

Video of my talk at the Haskell Implementors' Workshop: 

The slides are available from a previous post: http://justtesting.posterous.com/haskell-arrays-accelerated-0

Filed under  //  edsl   gpgpu   haskell   parallelism  
Posted