Introduction

GPGPU stands for General-Purpose computation on GPUs. With the increasing programmability of commodity graphics processing units (GPUs), these chips are capable of performing more than the specific graphics computations for which they were designed. They are now capable coprocessors, and their high speed makes them useful for a variety of applications. The goal of this page is to catalog the current and historical use of GPUs for general-purpose computation.

Subscribe to a syndicated RSS feed of GPGPU.

GPGPU DEVELOPER RESOURCES

Welcome to the GPGPU.org Developer Resources page. Here you will find information about GPGPU programming, including links, sample code, tutorials, and more. All of the code here is open source, and most is available via SourceForge.

The GPGPU.org Wiki contains many resources useful for developers, such as:

• Recommended reading material
• Frequently Asked Questions
• Glossary of GPGPU keywords
• and much more

Over the years several GPGPU Tutorial sessions have been hosted at various conferences.

• ARCS 2008 GPGPU Tutorial
• Supercomputing 2007 CUDA Tutorial
• SIGGRAPH 2007 GPGPU Tutorial
• Supercomputing 2006 GPGPU Tutorial
• ICCS 2006 GPGPU Tutorial
• SIGGRAPH 2005 GPGPU Tutorial
• Visualization 2005 GPGPU Tutorial
• SIGGRAPH 2004 GPGPU Tutorial
• Visualization 2004 GPGPU Tutorial

GPGPU programming can be tricky. The simple examples provided here should help new GPGPU programmers get started.

Tutorial 0: "Hello GPGPU"

Note: You can also download the GLSL Version

This introductory tutorial teaches five essential GPGPU concepts through the example application of a real-time edge detection filter.

1. Texture = Array
2. Fragment Program = Computational Kernel
3. One-to-one Pixel-to-Texel Mapping:
• Data-Dimensioned Viewport, and
• Orthographic Projection
4. Viewport-Sized Quad = Data Stream Generator
5. Copy To Texture = feedback

The tutorial requires the Cg toolkit and GLUT.

Tutorial 1: "Basic Concepts"

This tutorial by Dominik Goeddeke expands on "Hello GPGPU" and discusses the various GPGPU programming concepts in much more detail. It is highly recommended for every beginner in the field of GPGPU programming to work through this tutorial. OpenGL code of a simple application that adds large floating point vectors on the GPU is included.

Basic Concepts Tutorial.

Tutorial 2: "Reductions"

The term "reduction" refers to operations that compute scalar values from vector data in parallel processing. Examples include maximum, minimum, dot products, norms etc. This tutorial by Dominik Goeddeke explains how this important building block can be implemented on GPUs.

Reduction Tutorial.

Tutorial 3: "Fast Transfers"

The AGP or PCIe bus can be a bottleneck in GPGPU applications, especially if much data needs to be transferred to and from the GPU. This tutorial by Dominik Goeddeke explains how to increase transfer speed on NVIDIA GPUs by taking advantage of the OpenGL pixel buffer extension.

Fast Transfers Tutorial.

Fluid Dynamics Simulation This sample from the NVIDIA SDK demonstrates fast, realistic fluid dynamics simulation on the GPU. The sample solves the Navier-Stokes equations for incompressible fluid flow using a technique originally presented at SIGGRAPH 1999 by Jos Stam. The sample allows the user to draw arbitrary obstacles and flow viscous or inviscid fluid around them.
Reaction-Diffusion: "Disease" This sample from the NVIDIA SDK creates a disturbing dynamic disease effect. It simulates a phenomenon known as chemical reaction-diffusion, by solving the governing partial differential equations in a fragment program. The result is an endless variety of changing patterns that are then used to generate bump and texture maps which are applied to a mesh with various shaders.
GPU Particles This sample implements a large-scale particle system entirely on the GPU. The positions and velocities of each particle are stored in floating point textures. Fragment programs are used to update the velocities and positions of the particles by rendering to texture each time step. The particles also collide against a sphere object, and a terrain heightfield which is stored in a texture. If available, the multiple draw buffers extension (MRT) is used to update the position and velocities in a single pass. The particles are rendered as point sprites. The position texture is converted into a vertex array for rendering the particles using the vertex buffer and pixel buffer object extensions (VBO and PBO). On the GeForce 6800, this method can render a million particles at about 20 frames per second. This example is inspired by Lutz Latta's talk from GDC 2004, "Building a Million Particle System". http://www.2ld.de/gdc2004/

If you have useful code you would like to share with the GPGPU community, use the "contact us" link at the left to tell the webmaster about it.

CUDPP

CUDPP is the CUDA Data Parallel Primitives Library. CUDPP is a library of data-parallel algorithm primitives such as parallel-prefix-sum ("scan"), parallel sort and parallel reduction. Primitives such as these are important building blocks for a wide variety of data-parallel algorithms, including sorting, stream compaction, and building data structures such as trees and summed-area tables.

Framebuffer Object (FBO) Class

This class is a minimal abstraction of the OpenGL framebuffer object (FBO) specification. FBO enables flexible, efficient render-to-texture in OpenGL and obviates the use of pbuffers. Included with this distribution is an example application that uses the FBO class (a slightly modified version of the "Hello GPGPU" tutorial). This code is generously provided by Aaron Lefohn.

FBO Class.

Please check SourceForge for updates to the FBO Class.

RenderTexture

Note: RenderTexture uses pbuffers, which are being replaced in OpenGL by the new FBO extension. See above. RenderTexture is a wrapper class that abstracts the process of creating and rendering to off-screen color and depth buffers in OpenGL. It supports Windows and Linux on NVIDIA and ATI graphics processors.

RenderTexture 2.0 is the latest incarnation of RenderTexture.

RenderTexture 1.0 is an older version with fewer features that may be more stable on some configurations.

Please check SourceForge for updates to RenderTexture.

Jump to...

Conference Tutorials
Code Tutorials
Code Samples
Utility Code

Links

NVIDIA CUDA
CUDPP
gpgpu.sourceforge.net
ShaderTech
The Cg Toolkit
GLUT