Just recently I tried rewriting OpenGL’s routines that handle matrix calculations as part of a lecture at the university. Pretty soon I came to the conclusion, that I had to optimize my code if I wanted to compete with the implementation provided by OpenGL.

This post presents at quick look at CPU Sampler which helped me making well-founded decisions resulting in a faster implementation.

Howto

Once you’ve developed your software with Xcode and want to profile it using CPU Sampler, all you have to do is to click on Run – Run with Performance Tool – CPU Sampler. This will start the tool and run your application; you can start and stop the recording as you see fit.

As soon as you end your application you can have a look at the samples collected during the last run. This is the interesting part because you can review how long a certain function was running and the percentage tells you how long this took compared to the overall run.

Try playing around with the various options. In most situations you can stick with the defaults but there’re more interesting things to look at if you want to. For example try changing the Active thread from All threads to something else and the view will show the corresponding samples only.

Example

As I said, I tried rewriting OpenGL’s routines that handle matrix calculations. This was meant as an exercise to understand the operations needed that changed the matrices. Of course, the implementation was way slower than OpenGL and I should try speeding it up.

Using CPU Sampler I immediately identified a bottleneck and a major difference between my implementation and the one that comes with OpenGL. The slow part of my code could be found in repeated calls to cos and sin. Since OpenGL seems to work with the libraries of my graphics card directly I guess it tries to do certain computations there.

What I now did was substituting the calls to cos and sin with code that used a lookup table to retrieve precalculated values. This resulted in a major performance boost – still, OpenGL’s code is twice as fast as my one.

Have a look at the following screenshots. They show a run using OpenGL’s implementation of matrix manipulations, my own and an optimized version of my own implementation. Comparing the naive and optimized version of my code clearly shows that the optimized variant doesn’t spent much time calculating cos and sin.

Conclusion

I wanted to show that using a profiling tool like CPU Sampler that comes with Apple’s Xcode may make your life much easier if you’re trying to optimize your application. This helps you to make wise decisions when it comes to optimizing code so you don’t have to obfuscate your software with hard to read code blocks that have a very little effect regarding performance.

It’s nice to see that Apple ships tools like this with its IDE. Have a look at the other performance tools and you’ll be amazed how many cools things Xcode is capable of – things you wouldn’t even dream about in other IDE’s.

It’s pretty easy as soon as you know that OpenGL blends the color between vertexes horizontally. Just setting the corners of the triangle to the three fundamental colors (RGB) hoping that the center gets white won’t cut it.

The goal

The result should display a triangle with a white center and corners showing different colors. Have a look at it here.

Solution

One solution is splitting the triangle into smaller ones. This way you can set the color of the vertex in the center to white – a vertex all three sub-triangles have in common – and change the color of the corners as you see fit.

You can have a look at the code here. Basically, it consists of some boilerplate code for OpenGL and a display function that contains the magic.

I’ve used a GL_TRIANGLE_FAN to construct the triangle. The vertexes are created in this order: center, top, bottom left, bottom right and top again. Right before every vertex definition the color is set like I wanted it.

Conclusion

In the end it’s simple to create a triangle with a white center. I hope this was helpful in understanding how shading works in OpenGL. Note that I’ve commented out a line in the code, try uncommenting it to see how the triangle really looks like.