0

Topic is pretty much the question. I'm trying to understand how CPU and GPU cooperation works.

I'm developing my game via cocos2d. It is a game engine so it redraws the whole screen 60 times per second. Every node in cocos2d draws its own set of triangles. Usually you set vertexes for triangle after performing node transforms (from node to world) on CPU side. I've realized the way to do it on GPU side with vertex shaders by passing view model projection to uniforms.

I see CPU time decreasing by ~1ms and gpu time raised by ~0.5ms. Can I consider this as a performance gain?

In other words: if something can be done on GPU side is there any reasons you shouldn't do it?

genpfault
  • 51,148
  • 11
  • 85
  • 139
Andrew Volodin
  • 159
  • 1
  • 10
  • If something can be done over and over with the same input state then it is very useful to set everything up and execute it over and over. But, in the case where just setting things up to execute on the GPU is a lot of work as compared to doing the calculations on the CPU, then you will not gain much. Image and Video rendering is a good example that can really benefit from exporting memory write operations to the GPU instead of CPU. There is a real gain when many operations can be done at the same time in parallel. For example see: http://stackoverflow.com/a/38679128/763355 – MoDJ Oct 27 '16 at 20:15

1 Answers1

1

The only time you shouldn't do something on the GPU side is if you need the result (in easily accessible form) on the CPU side to further the simulation.

Taking your example. If we assume you have 4 250KB meshes which represent a hierarchy of body parts (as a skeleton). Lets assume you are using a 4x4 matrix of floats for the transformations (64bytes) for each mesh. You could either:

  1. Each frame, perform the mesh transformation calculations on the application side (CPU) and then upload the four meshes to the GPU. This would result in about ~1000kb of data being sent to the GPU per frame.

  2. When the application starts, upload the data for the 4 meshes to the GPU (this will be in a rest / identity pose). Then each frame when you make the render call, you calculate only the new matrices for each mesh (position/rotation/scale) and upload those matrices to the GPU and perform the transformation there. This results in ~256bytes being sent to the GPU per frame.

As you can see, even if the data in the example is fabricated, the main advantage is that you are minimizing the amount of data being transferred between CPU and GPU on a per frame basis.

The only time you would prefer the first option is if your application needs the results of the transformation to do some other work. The GPU is very efficient (especially at processing vertices in parallel), but it isn't too easy to get information back from the GPU (and then its usually in the form on a texture - i.e. a RenderTarget). One concrete example of this 'further work' might be performing collision checks on transformed mesh positions.

edit You can tell based on how you are calling the openGL api where the data is stored to some extent*. Here is a quick run-down:

Vertex Arrays

glVertexPointer(...)
glDrawArray(...)

using this method passing an array of vertices from the CPU -> GPU each frame. The vertices are processed sequentially as they appear in the array. There is a variation of this method (glDrawElements) which lets you specify indices.

VBOs

glBindBuffer(...)
glBufferData(...)
glDrawElements(...)

VBOs allow you to store the mesh data on the GPU (see below for note). In this way, you don't need to send the mesh data to the GPU each frame, only the transformation data.

*Although we can indicate where our data is to be stored, it is not actually specified in the OpenGL specification how the vendors are to implement this. It means that, we can give hints that our vertex data should be stored in VRAM, but ultimately, it is down to the driver!

Good reference links for this stuff is:

OpenGL ref page: https://www.opengl.org/sdk/docs/man/html/start.html

OpenGL explanations: http://www.songho.ca/opengl

Java OpenGL concepts for rendering: http://www.java-gaming.org/topics/introduction-to-vertex-arrays-and-vertex-buffer-objects-opengl/24272/view.html

LintfordPickle
  • 420
  • 4
  • 13