Performance on linux(windows, pixmaps, pbuffers)


I have done some tests recently with linux(latest nvidia drivers 87.56,fedora core, 6600gt) and glx and would like to share my results with you. Basically, I was looking for a possibility for rendering my scene offscreen and then drawing it to teh window. I didn’t do exact time measures, it is all relative.

The fastest way was rendering to a window and rendering to a pixmap + copy to window (about the same time) via an indirect rendering context.

Finally, rendering to a pbuffer with getpixels was about 70000 slower then pixmaps.

Performance of only rendering was about the same for window, pbuffer and pixmap via an indirect context. Whiel rendering to pbuffer the performance of both indirect and direct context was the same, rendering to the window via direct context was MUCH slower.

Hence a logical question arises: what are pbuffers good for actually when I can use pixmaps with exacly the same performance? And what are direct rendering contexts good for if they are slower + don’t support rendering to pixmaps?

I hope someone could comment on this…

I’m pretty sure you’ve done something wrong with your measurments. Theoretically, rendering to a pixmap should give you software rendering, so I guess you also got software rendering when rendering to a window. Also, indirect rendering should go through the GLX protocol over the loopback network, so I’m almost sure it should be software, or at least a bit slower.

Are you sure your scene is complex enough to notice the performance difference between software and hardware rendering? Do you use shaders? Try querying the extension list for all three rendering methods (direct, indirect, pixmap).

Rendering to a pbuffer and then calling getpixels is absolutely killing performance, since you are transferring data back to the CPU. Try rendering to a texture instead. Also you should try out the new framebuffer object extension.

Try to give the first lines of glxinfo.

Ok, me again :slight_smile:

Both types of contexts (direct or indirect) give me the same renderer and version string etc., so I suppose they are both hardware. The GL version is always 2.0.2

Hovewer, the funny thing is that all shader-based functionality(liek ARB_shader_object or the GL2 version) is not present in indirect contexts, while vertex and fragment programs actually are. I tested both type sof contexts using a simple fragment program, and guess what, indirect contexts (including render to pixmap) were still up to 10 times faster than the direct ones. I cannot realy imagine running it in software as I am rendering 1000 batches with depthtest disabled. The pixture quality is exacly the same with both direct and indirect contexts.

Now I am really irritated…

This topic was automatically closed 183 days after the last reply. New replies are no longer allowed.