Should I calculate matrices on the GPU or on the CPU?

52
votes

Should I prefer to calculate matrices on the CPU or GPU?

Let's say I have the following matrices P * V * M , should I calculate them on the CPU so that I can send the final matrix to the GPU (GLSL) or should I send those three matrices separately to the GPU so that GLSL can calculate the final matrix?

I mean in this case GLSL would have to calculate the MVP matrix for every vertex, so it is probably faster to precompute it on the CPU.

But let's say that GLSL only has to calculate he MVP matrix once, would the GPU calculate the final matrix faster than the CPU?

2
openglcomputer-visionglsl
Can you give an example that you only perform this calculation once in GPU? – Amadeus
1. Optimize last. Are you sure you're not just procrastinating? :) 2. If you can't measure performance and identify bottlenecks, don't think about optimization. – Andreas Haferburg
Just a note, if you are directly multiplying a vector, as in projection * view * model * vertex Then there are actually no matrix multiplications. Only matrix * vector multiplications since it is evaluated from right to left (projection * (view * (model * vertex))). This is much less burdensome on calculation. – Justin Meiners

2 Answers

79
votes

General rule: If you can pass it to a shader in form of a uniform, always precalculate on the CPU; no exceptions. Calculations on the shader side make sense only for values that vary between vertices and fragments. Everything that's constant among a whole batch of vertices is most efficiently dealt with on the CPU.

GPUs are not magic "can do faster everything" machines. There are certain tasks where a CPU can easily outperform a GPU, even for very large datasets. So a very simple guideline is: If you can move it to the CPU without spending more CPU time doing the calculation than it takes for the GPU in total overhead to process it, then do it on the CPU. The calculation of a single matrix is among those tasks.

16
votes

Like most situations with OpenGL, it depends.

In most cases, a single calculation can be done faster on the CPU than on the GPU. The GPU's advantage is that it can do lots of calculations in parallel.

On the other hand, it also depends where your bottlenecks are. If your CPU is doing lots of other work, but your shaders are not a bottleneck yet on the lowest-powered target system, then you could easily see some performance improvement by moving some matrix multiplications to the vertex shader.

Generally, you should avoid any work in the fragment shader that could also be done in the vertex shader or on the CPU, but beyond that, it depends on the situation. Unless you are running into performance issues, just do it whatever way is easiest for you, and if you are having performance issues, do it both ways and profile the performance to see which works better.