GPGPU

From CFD-Wiki

(Difference between revisions)

Revision as of 01:44, 18 March 2010

Introduction

GPGPU is an acronym for General Purpose Graphic Processor Unit. A GPGPU is any graphics processor being used for general computing beyond graphics. GPUsare widely available, and often targeted at the computer gaming industry. Graphics workloads are very parallel, and so GPUs developed as large-scale parallel computation machines. Originally GPGPU processing was done by tricking the GPU by disguising computation loads as graphic loads. In recent years, GPU manufacturers have been actively encouraging GPGPU computing with the release of specialized languages which support GPGPU commands. GPUs incorporate many more computational cores than their equivalent CPUs, and so the performance of parallel operations can be greatly enhanced. Programming in parallel on a GPU has the same justification given for parallel computing in general.

Application to CFD

GPGPU computing offers large amounts of compute power, which can be tapped for parallel components of CFD algorithms, while the CPU performs the serial portions of the algorithm. GPGPU languages also support data-parallel computation, similar to vector processors. In short, modern GPUs provide raw computational power orders of magnitude larger than a CPU and can fit inside a single computer case.

Graphics Architecture

 This section is written by a non english speaker; please excuse the bad grammar (And correct it!).

A GPU has a main memory (up to 1536 MB in 2010), many stages and parallel processors. Traditional GPUs have a linear pipeline with several distinct stages: application, command, geometry, rasterization, fragment, and display. Intel's project Larrabee promises a reconfigurable graphics pipeline, with many of the traditional steps being handled in software. Such a development would expose even more of the GPUs compute power to parallel programmers.

Traditional Pipeline

A traditional pipeline will have three main computation stages: geometry, rasterization, and fragment. Graphics is traditionally done with triangles, and a GPU will operate on a batch of triangle verticies to first create fragments, which will help create the pixels that end up on the monitor.

Geometry

Vertex processing is handled in the geometry step. Geometry from the CPU is transformed based on the vertex shaders (programs) written to the GPU. These processors specialized in matrix transformations. Common operations include projecting 3D coordinates onto 2D screen coordinates. The closest analogue would be a vector or quaternion processor since each vector operation takes a series of components which represent a triangle vertex. Lagrangian frame computations might be well suited to vertex shaders.

Rasterization

Rasterization takes the transformed vectors from the geometry step and creates fragments from the geometry. The easiest way to think of rasterization, is "chunking" a large triangle into many fragments. This stage is typically done with fixed function specialized hardware.

Fragment

Fragment processing requires floating point math, as the fragments are colored and filtered to become pixels. This stage is where muchof the interesting compute for CFD can happen, as the parallel floating point processors can be repurposed with either fragment shaders or special purpose languages to do non-graphics floating point math.

Performance

In a Geforce 7800 have been measured 160 Gigaflops (not peak, but maintained performance). But expect half to 1/3 this power in a general purpose/novice program. There are at least double chips video cards, and PC motherboards that support up to 4 video cards. This mean 160x2x4=1.2 Teraflops (1.2/2=600 Gigaflops) on one PC with 512*4=2 Gb of 'video' RAM. But nvidia drivers support transparently only up to 2 chips running like one and without the double of memory. Then, for the novice there are only (160/3)x2=100 Gflops and 512 Mb of video RAM available on 2005 at cost of near 1000 U$S. In comparison, there is possible to put 2 x86 processors with double CPU on a motherboard, allowing up to a peak of 15/20*4=60/80 Gflops in a PC, that can be reached by programs that not fill the cache.

Languages

Is possible to program directly with OpenGL Shading Language --, his equivalent of Microsoft, DirectX shading language HLSL, or Nvidia CG ; all in a format very similar to c/c++. OpenGL and CG are full portable to non Microsoft environments. Those 3 languages are almost identical. Also exist languages like and c/c++ libraries/wrappings. Since representation of CFD data requires graphic drawing, learning OpenGl is extremely useful for CFD, and from here, programming GPUs is a very straight forward step to do.

References

Guides and Information

GPU Gems Fluid Chapter

www.opengl.org

GLSL

Journalism

Two's Company, Four's a WOW! Sneak Preview of NVIDIA Quad GPU SLI

This article is a stub, a short article which needs to be improved. You can help by expanding it.

@@ Line 7: / Line 7: @@
 ==Graphics Architecture==
    This section is written by a non english speaker; please excuse the bad grammar (And correct it!).
-A graphic unit have a main memory (up to 256/512 Mb by card in 2005), and a graphic processor with many stages and parallel processors; each stage trow his output data on the next stage.
+A GPU has a main memory (up to 1536 MB in 2010), many stages and parallel processors.  Traditional GPUs have a linear pipeline with several distinct stages: application, command, geometry, rasterization, fragment, and display.  Intel's project [http://en.wikipedia.org/wiki/Larrabee_%28microarchitecture%29 Larrabee] promises a reconfigurable graphics pipeline, with many of the traditional steps being handled in software.  Such a development would expose even more of the GPUs compute power to parallel programmers.
-First stage:
+===Traditional Pipeline===
-Commonly is the vertex processor. It have commonly less parallel processors than fragment stage.
+A traditional pipeline will have three main computation stages: geometry, rasterization, and fragment.  Graphics is traditionally done with triangles, and a GPU will operate on a batch of triangle verticies to first create fragments, which will help create the pixels that end up on the monitor.
-The vertex processor does calculations specialized in matrix transformations. Typically project 3D coordinates in 2D screen coordinates, but is not restricted to matrix products.
+====Geometry====
-It can be thought of as a vector -or quaternion- processor, since a vertex is one or two vector of 4 components representing a triangle vertex.
+Vertex processing is handled in the geometry step.  Geometry from the CPU is transformed based on the vertex shaders (programs) written to the GPU.  These processors specialized in matrix transformations.  Common operations include projecting 3D coordinates onto 2D screen coordinates.  The closest analogue would be a vector or quaternion processor since each vector operation takes a series of components which represent a triangle vertex. Lagrangian frame computations might be well suited to vertex shaders.
-It adapt well to Lagrangian frames.
-Middle stage:
+====Rasterization====
-Then, follow a (still non programmable) stage where linear interpolations, and other works are done. This stage has poor flexibility, but can be useful to specialized tasks.
+Rasterization takes the transformed vectors from the geometry step and creates fragments from the geometry.  The easiest way to think of rasterization, is "chunking" a large triangle into many fragments.  This stage is typically done with fixed function specialized hardware.
-Third stage:
+====Fragment====
-The last stage, the more useful for CFD, is the fragment processor. Latest GPUs from 2005 have up to 24 parallel fragment processors, capable of process 4 IEEE floating point each one (24x4=96 parallel calculus!); here 2D matrix of four numbers are processed. They map to 2D screen pixels containing four numbers -Red, Green, Blue and Alpha components of pixels- Can be thought like a 4096x4096x4 matrix of 32 bits numbers/data.
+Fragment processing requires floating point math, as the fragments are colored and filtered to become pixels.  This stage is where muchof the interesting compute for CFD can happen, as the parallel floating point processors can be repurposed with either fragment shaders or special purpose languages to do non-graphics floating point math.
 ===Performance===