JeGX's Infamous Lab

Archive for March, 2008

I found this thread on [H]ard|Forum where we can read this:

“That fur demo is known to get cards the hottest, it is also known for smoking cards as well (it was the last thing run for a number of people on the extremesystems forums).”

I knew FurMark was good for heating the graphics cards up but I didn’t know it’s also good to really kill them. I feel the summer will be hot for some graphics cards…

Here is the list of OpenGL extensions supported by Forceware 174.20 drivers.

OpenGL Extensions: 161 extensions

Read the rest of this entry »

Here is the list of OpenGL extensions supported by Catalyst 8.3 drivers. There are 96 extensions.

• Drivers Version: 8.471.0.0 – Catalyst 08.3
• ATI Catalyst Version String: 08.3
• ATI Catalyst Release Version String: 8.471-080225a1-059746C-ATI

Read the rest of this entry »

This demo uses instancing techniques (simple instancing, pseudo-instancing and geometry instancing(or GI)) to render a ring made of 10,000 small spheres. The demo is delivered in 5 versions:

• each sphere is made of 1,800 triangles (18 millions triangles for the whole ring)
• each sphere is made of 800 triangles (8 millions triangles for the whole ring)
• each sphere is made of 200 triangles (2 millions triangles for the whole ring)
• each sphere is made of 72 triangles (720,000 triangles for the whole ring)
• each sphere is made of 18 triangles (180,000 triangles for the whole ring)

I added in the last moment a bonus: a 20,000 instances version, each instance made of 5,000 triangles. We get the monstruous count of 100 millions triangles (file Demo_Instancing_100MTriangles_20kInstances.exe).

DOWNLOAD

OpenGL Instancing DemoPack – (2676k)

Several instancing techniques are used and you can select them with F1 to F6 keys.

• F1: simple instancing with camera frustum culling: there is one source for geometry (a mesh) and it’s rendered for each instance. The tranformation matrix calculation is done on the CPU as well as the camera frustum test. OpenGL rendering uses the glDrawElements() function.
• F2: simple instancing without camera frustum culling: there is one source for geometry (a mesh) and it’s rendered for each instance. The tranformation matrix calculation is done on the CPU but there is no longer camera frustum test. OpenGL rendering uses the glDrawElements() function.
• F3: slow pseudo-instancing: there is one source for geometry (a mesh) and it’s rendered for each instance. Now the tranformation matrix calculation is done on the GPU and per-instance data are passed via uniform variables. There is no camera frustum test. OpenGL rendering uses the glDrawElements() function.
• F4: pseudo-instancing: there is one source for geometry (a mesh) and it’s rendered for each instance. The tranformation matrix calculation is done on the GPU and per-instance data are passed via persistent vertex attributes (like texture coordinates or color). This technique has been shown by NVIDIA in the following whitepaper: GLSL Pseudo-Instancing. There is no camera frustum test. OpenGL rendering uses the glDrawElements() function.
• F5: geometry instancing: it’s the real hardware instancing. There is one source for geometry (a mesh) and rendering is done by batchs of 400 instances per draw-call. The whole rendering of the ring requires 25 draw-calls instead of 10,000. The tranformation matrix calculation is done on the GPU and per-batch data is passed via uniform arrays. There is no camera frustum test. OpenGL rendering uses the glDrawElementsInstancedEXT() function. Currently, only NVIDIA GeForce 8 (and higher) support this function.
• F6: geometry instancing with persistant vertex attributes: it’s the hardware instancing coupled with the transmission of parameters is done via the persistent vertex attributes. But the number of persistent vertex attributes is very limited. The best I did is to render 4 instances per draw-call. But oddly, I got the best results with 2 instances per draw-call. In that case, the rendering of whole ring requires 5000 draw-calls. The tranformation matrix calculation is done on the GPU and per-batch data is passed via uniform arrays. There is no camera frustum test. OpenGL rendering uses the glDrawElementsInstancedEXT() function. Currently, only NVIDIA GeForce 8 (and higher) support this function.

Ok now, let’s see some results with a NVIDIA GeForce 8800 GTX and an ATI Radeon HD 3870. Both cards have been tested with an AMD 64 3800+.

18 millions triangles – 1800 tri/instance

NVIDIA GeForce 8800 GTX – Forceware 169.38 XP32

• F1: 223MTris/sec – 13FPS
• F2: 223MTris/sec – 13FPS
• F3: 223MTris/sec – 13FPS
• F4: 223MTris/sec – 13FPS
• F5: 223MTris/sec – 13FPS
• F6: 171MTris/sec – 10FPS

ATI Radeon HD 3870 – Catalyst 8.2 XP32

• F1: 429MTris/sec – 25FPS
• F2: 463MTris/sec – 27FPS
• F3: 446MTris/sec – 26FPS
• F4: 274MTris/sec – 16FPS
• F5: mode not available
• F6: mode not available

8 millions de triangles – 800 tri/instance

NVIDIA GeForce 8800 GTX – Forceware 169.38 XP32

• F1: 190MTri/sec – 25FPS
• F2: 190MTri/sec – 25FPS
• F3: 205MTri/sec – 27FPS
• F4: 213MTri/sec – 28FPS
• F5: 205MTri/sec – 27FPS
• F6: 152MTri/sec – 20FPS

ATI Radeon HD 3870 – Catalyst 8.2 XP32

• F1: 251MTris/sec – 33FPS
• F2: 236MTris/sec – 31FPS
• F3: 297MTris/sec – 39FPS
• F4: 251MTris/sec – 33FPS
• F5: mode not available
• F6: mode not available

2 millions de triangles – 200 tri/instance

NVIDIA GeForce 8800 GTX – Forceware 169.38 XP32

• F1: 47MTri/sec – 25FPS
• F2: 47MTri/sec – 25FPS
• F3: 57MTri/sec – 30FPS
• F4: 131MTri/sec – 69FPS
• F5: 167MTri/sec – 88FPS
• F6: 148MTri/sec – 78FPS

ATI Radeon HD 3870 – Catalyst 8.2 XP32

• F1: 47MTris/sec – 25FPS
• F2: 59MTris/sec – 31FPS
• F3: 74MTris/sec – 39FPS
• F4: 112MTris/sec – 59FPS
• F5: mode not available
• F6: mode not available

720,000 triangles – 72 tri/instance

NVIDIA GeForce 8800 GTX – Forceware 169.38 XP32

• F1: 17MTri/sec – 25FPS
• F2: 17MTri/sec – 25FPS
• F3: 20MTri/sec – 30FPS
• F4: 47MTri/sec – 69FPS
• F5: 60MTri/sec – 88FPS
• F6: 53MTri/sec – 78FPS

ATI Radeon HD 3870 – Catalyst 8.2 XP32

• F1: 17MTris/sec – 25FPS
• F2: 21MTris/sec – 31FPS
• F3: 26MTris/sec – 39FPS
• F4: 40MTris/sec – 59FPS
• F5: mode not available
• F6: mode not available

180000 triangles – 18 tri/instance

NVIDIA GeForce 8800 GTX – Forceware 169.38 XP32

• F1: 4MTri/sec – 25FPS
• F2: 4MTri/sec – 25FPS
• F3: 5MTri/sec – 30FPS
• F4: 11MTri/sec – 69FPS
• F5: 15MTri/sec – 89FPS
• F6: 13MTri/sec – 79FPS

ATI Radeon HD 3870 – Catalyst 8.2 XP32

• F1: 4MTris/sec – 25FPS
• F2: 5MTris/sec – 31FPS
• F3: 6MTris/sec – 39FPS
• F4: 10MTris/sec – 59FPS
• F5: mode not available
• F6: mode not available

Quick results analysis:

• we now understand why NVIDIA has called the technique using persistent vertex attributes “Pseudo-Instancing” (key F4). OpenGL glDrawElements() function is extremly fastand persistent vertex attributes require less overhead than uniforms to be passed to vertex shader. Both coupled together give this performance boost.
• benefit of real hardware geometry instancing is mostly visible with few triangles per instance.
• when there are many triangles per instance (1,800), the hardware implementation of glDrawElements() seems to be more efficient (twice!) on RV670 GPU than on G80.

Conclusion

From the results, hardware geometry instancing isn’t the kill-feature I expected. I find that very weird since the différence between 10000 render-calls with glDrawElements and 25 render-calls with glDrawElementsInstancedEXT is not verx important. Seems the instancing management (gl_InstanceID variable in the vertex shader) is a GPU-cycle eater!What a pity ATI hasn’t implemented yet geometry instancing in the Catalyst drivers. I’d be very curious to test hardware GI with a RV670.