This paper by Kolb and Cuntz from the computer graphics group of the University of Siegen describes a 3D flow simulation approach on the GPU. The flow simulation is modeled using the so-called Smoothed Particle Hydrodynamics approach. The presented technique combines the particle simulation, presented by Kipfer et.al. and Kolb et.al. at Graphics-Hardware 2004, with a grid based approach. 3D grids are used to store intermediate flow quantities that are distributed by the particles in their neighborhood. MRT is used to compute the contribution of a single particle to four texture slices simultaneously. Blending the individual contribution of all particles in 16bit textures yields the final 3D force fields used for the simulation of particle motion. (Dynamic Particle Coupling for GPU-based Fluid Simulation)
This paper describes Accelerator, a system that simplifies the programming of GPUs for general-purpose uses. Accelerator provides a high-level data-parallel programming model as a library that is available from a conventional imperative programming language (C#). The library translates the data-parallel operations on-the-fly to optimized GPU pixel shader code and API calls. The authors describe the compilation techniques used to produce optimized pixel shader code, and demonstrate the effectiveness of the approach by providing results for a set of compute-intensive benchmarks drawn from image processing and computer vision. The speeds of the Accelerator versions of the benchmarks are typically within 50% of the speeds of hand-written pixel shader code. Some benchmarks significantly outperform C versions running on a CPU by up to 18x. (Accelerator: simplified programming of graphics processing units for general-purpose uses via data-parallelism. David Tarditi, Sidd Puri, Jose Oglesby. Microsoft Research Technical Report MSR-TR-2005-184. December 2005.)
This paper by Boubekeur and Schlick of the INRIA IPARLA Team describes a simple and easy-to-integrate method for “on-GPU refinement” (tesselation + displacement), adapted to any programmable GPU. This solution to the refinement problem reduces the usual CPU->GPU bottleneck and memory consumption by using instantiation over a template refinement pattern. This approach is usuful for rendering objects that are represented as a simple mesh plus a detailed displacement requiring deep tesselation (high-res maps, smooth surfaces, procedural displacement, etc). (Generic Mesh Refinement on GPU. Tamy Boubekeur and Christophe Schlick. Proceedings of Graphics Hardware 2005).
Eric Haines has released the latest issue of his long-running “Ray Tracing News”. It’s chock full of news and interesting discussion about ray tracing implementation and optimization, kd-trees, and more. It also includes links to various ray-tracing work being done on GPUs. (Ray Tracing News volume 18, no. 1)
gDEBugger, an OpenGL debugger and profiler, traces application activity on top of the OpenGL API, letting programmers see what is happening within the graphics system implementation to find bugs and optimize application performance. The new V2.2 introduces a shader “Edit and Continue” ability which allows you to edit, save and compile shader source code, link and validate programs “on the fly”. This feature saves developer time required for rebuilding and re-running the debugged application. This version also adds support for 8 additional OpenGL extensions. (http://www.gremedy.com)
The code from the paper “LU-GPU: Algorithms for Dense Linear Systems on Graphics Hardware” has been released. The API is based on LAPACK and should be easy for anyone to use. (LUGPULIB)
The complete course notes have been posted for the full-day GPGPU course held at IEEE Visualization 2005. The course titled, “GPGPU: General Purpose Computing on Graphics Processors” was held on Sunday, October 23rd, 2005 in Minneapolis, Minnesota. The course begins with the architectural, economic, and programmatic motivations behind GPGPU. It then introduces the GPGPU programming model and describes GPGPU languages (Brook, Scout) as well as high-level data structures. Mathematical and algorithmic primitives are then presented, followed by descriptions of many of the low-level technical details required for effective real-world GPGPU programming. The course concludes with several case studies and a disscusion of the future architectual, application, and research possibilities for GPGPU. The course organizer was Aaron Lefohn, and the presenters were Ian Buck, Aaron Lefohn, John Owens, Tim Purcell, Patrick McCormick, and Robert Strzodka. ( “GPGPU: General
Purpose Computing on Graphics Processors,” IEEE Visualization 2005)
Sh Version 0.8.0rc0, the first release candidate for the upcoming Sh 0.8, is now available. There are plenty of new features and bug fixes, but most importantly this release has an API that completely matches the book Metaprogramming GPUs with Sh, which the 0.8.x series of releases will stick to. (http://libsh.org)
A special workshop dedicated to “GPGPU: Methods, algorithms and applications” will be hosted in conjunction with the 6th International Conference On Computational Science (ICCS 2006). The primary goal of this session is to present the GPU as a powerful parallel processor. Contributions presenting novel, original work in all areas of GPGPU, e.g. from hardware abstractions to specific applications, are cordially invited. For more information, please refer to the official workshop web page.
Jens Schneider, Polina Kondratieva, Jens Krüger, and Rüdiger Westermann from TU Munich have won the 2005 IEEE Visualization Contest with their work “All you need is particles!” Check out the video of their results; it’s very interesting.