Can using different vertex-buffers for each vertex-attributes be good in certain scenarios?

Question

Is there scenarios where this is actually good practice? Or does it slow down performance?

Example:

//Vertex format is:
//X, Y, U, V
var myXYs:Vector.<Number> = new <Number>[
  -1, -1,
  1, -1,
  1, 1,
  -1, 1
];

var myUVs:Vector.<Number> = new <Number>[
  0, 0,
  1, 0,
  1, 1,
  0, 1
]

//Create actual VertexBuffers....
// ...yaddiyaddiyadda...

//Set context3d's vertex-attributes:
//Assign 'va0':
context3D.setVertexBufferAt(0, bufferXY, 0, Context3DVertexBufferFormat.FLOAT_2);
//Assign 'va1':
context3D.setVertexBufferAt(1, bufferUV, 0, Context3DVertexBufferFormat.FLOAT_2);

Would the GPU have to constantly internally 'swap' between bufferXY and bufferUV to process the vertex-data? Or does it handle it just as good as a single vertex-buffer?

NOTE: My goal is to figure out a way to minimize uploading data from CPU to GPU for a large number of objects (more than the 128 limit with vertex-constants in Stage3D) by manipulating a list of vertices only responsible for the position of objects rather than the entire geometry + color and/or UV coordinates.

Answer 1

If you're fetching all the vertex attributes in the shader, then in general attributes in multiple streams may be slower than all attributes in one stream, due to the loss of cache locality. However, using multiple streams can still be a good idea in some cases, such as:

1. Some passes only need to read a few of the attributes. For example, drawing the object into the shadow map usually only needs positions and is vertex bound, so it can be a win to have the positions set aside in their own stream.
2. Some attributes are static and some are dynamic. This sounds like your proposed solution. You may be able to save bandwidth overall by keeping the static attributes and the dynamic ones in separate vertex buffers so you only need to update the dynamic ones.
3. Instancing, where the inner and outer attributes must be in separate streams. This is probably what you should be doing if you're rendering many copies of an object, since it lets you have an outer vertex buffer with one entry per object and an inner vertex buffer with the the vertices for one copy of the object.

In any of these cases the slowdown due to fetching from multiple streams (which may be slight) can be offset by the reduced use of bandwidth overall. As always, the golden rule is to profile it. YMMV, as these things are very dependent on hardware and on details of your shaders and scenes. Measure the performance and see what's fastest for your case.