you may need to test this...

for example, I have had reasonably good success doing things like streaming videos into textures (such as 8 video streams at a time), but on some older hardware (~ 10 years ago), this would put some hurt on the performance.

This is one of those things that could be reasonably cheap or could be horribly expensive, depending how you need to do the update, what formats you use, and so on.

First thing is to batch up your updates. A single glTexSubImage call updating the entire texture will perform better than lots of calls updating tiny subrects of it.

Try to divide your workload into updating, then drawing. If you need to update/draw/update/draw/etc your performance will tank, especially on Intel or AMD hardware (NV tolerates this pattern better, but it's still a slower path).

Watch your formats; you absolutely must match the data you feed to glTexSubImage with the drivers preferred internal representation. Normally that means using a BGRA format. Don't fall into the trap of using RGB because you think it will "save memory" - the driver will need to unpack and reswizzle the data as a slow software process and again your performance will tank. Experiment with different values for the type param - GL_UNSIGNED_INT_8_8_8_8_REV can work well here.

Finally, and if you can schedule the update for a few frames ahead of when the texture is needed, consider using a PBO to get an asynchronous transfer. If you need to update in the same frame as the texture is used don't bother with the PBO - it's just extra overhead.

The OpenGL drivers are one factor, which means it depends on a very wide number of factors, so what works best for you may not for another.

One universal truth however is that if you update a texture while it is still being used by the GPU the GPU will perform a synchronous flush in order to allow you to update the texture safely on the CPU side.

This will be terrible performance no matter what API you use or hardware you have etc.

If you need to update the texture frequently or if your updates always cover the whole body of the texture, you should double-buffer the texture, or possibly triple-buffer it.

L. Spiro

One universal truth however is that if you update a texture while it is still being used by the GPU the GPU will perform a synchronous flush in order to allow you to update the texture safely on the CPU side.

I would hope that in this case drivers are at least reasonably intelligent and copy off the data to temp storage for updating at a later time when the resource is no longer in use (similar to the D3D10+ case for UpdateSubresource where there is contention, although unfortunately OpenGL doesn't seem to specify a behaviour here).

One universal truth however is that if you update a texture while it is still being used by the GPU the GPU will perform a synchronous flush in order to allow you to update the texture safely on the CPU side.

I would hope that in this case drivers are at least reasonably intelligent and copy off the data to temp storage for updating at a later time when the resource is no longer in use (similar to the D3D10+ case for UpdateSubresource where there is contention, although unfortunately OpenGL doesn't seem to specify a behaviour here).

when messing around with multithreaded OpenGL and texture uploading (with the rendering and texture-uploading being done in different threads), I observed some interesting behaviors here:

the glTexImage2d() or glCompressedTexImage2d() calls were completing immediately;

within the main render thread, it would often be up to several seconds later until the texture image actually appeared (otherwise, it would be the prior contents and/or garbage).

typically, having the uploader threads call glFinish() would cause them to stall temporarily, but results in the next frame in all of the textures being correct.

judging by this, I suspect the driver is lazily updating the textures in this case.

I am less certain what happens in the single-threaded case, but have made another general observation:

if you do something, and try to immediately make use of the results, there will be a stall.

this seems to happen with both VBOs and also things like occlusion queries, like there is a delay between when the upload call is made, and when it can be bound or used.

typically, in my case this means "batching" things and doing them in a partly interleaved order (say, all the draw requests for occlusion queries before fetching any of the results, or uploading all the updated VBOs before the rest of the drawing pass begins, ...).

granted, I am not sure how much of this is driver/hardware specific. in this case, I am using a GeForce GTX 460...

If you need to update the texture frequently or if your updates always cover the whole body of the texture, you should double-buffer the texture, or possibly triple-buffer it.

Very interesting, I didn't know textures could be double-buffered. Do you have any links on doing this in OpenGL?

There's no specific OpenGL technique for this. Instead you allocate two textures (let's call them 0 and 1), then update texture 0/draw using texture 1 and vice-versa on alternate frames.

There's no specific OpenGL technique for this. Instead you allocate two textures (let's call them 0 and 1), then update texture 0/draw using texture 1 and vice-versa on alternate frames.

But I'm assuming you can't have both textures bound for this to work, right? If you updated texture 0, and the shaders knew to only sample from texture 1 this frame, would the GPU really know that texture 0 wasn't accessed? Or would you still end up with a synchronous flush from updating texture 0?

AFAICT, "the magic" happens when you try to bind and draw using the texture or similar.

so, if the texture is updated but never used, there wont really be a stall (and the driver will update it later at some point).