C++ Optimization Strategies and Techniques

Many software engineers recommend what I call the "procrastination approach" to optimization. Delay optimization as much as possible, and don't do it if you can avoid it. I agree with the basic premise. Optimizing too early or too often is not a good approach to engineering. Better to have a program that runs than a fast program that crashes. On the other hand, you're not likely to write a successful app these days without doing optimization at some point in the process. Your compiler can help you, but you as a programmer understand more about your application than the compiler. As Michael Abrash puts it, the best compiler is "between your ears."

There are many levels of optimization, but I'm going to focus on one in particular: C++ optimizations. Some of these techniques apply to other languages as well - like Java - but most are specific to C++. I'll also cover how to configure your compiler for maximum C++ efficiency.

I originally wrote this document in 1998. A lot has changed since then, though many of the techniques listed are still relevant and valuable depending on your platform and compiler. As always, never accept optimization techniques at face value. Measure, measure, measure.

All performance graphs show relative performance. If the unoptimized run takes 200mS and the optimized run takes 100mS, the optimized run will be shown as twice as tall as the unoptimized run (i.e. twice as fast). In other words, taller is better.

Most code examples use the following C++ objects for comparison

• int
• string (standard C++ basic_string<char> class with an average of 32 characters per string)
• complex (standard C++ complex<double> class containing two double values)
• bitmap (bitmap class with expensive default and copy ctor; average of 10000 pixels)

There's a right way and a wrong way to do optimization. Here's some strategies common to all programming endeavors that work and don't work.

When you start working on your next app and begin to think about coding conventions, compilers, libraries, and general C++ issues, there are many factors to consider. In this section I weigh performance issues involved with C++ design considerations.

Defy the software engineering mantra of "optimization procrastination." These techniques can be added to your code today! In general, these methods not only make your code more efficient, but increase readability and maintainability, too.

Your app is up and running. The data structures are ideal, the algorithms sublime, the code elegant, but the program - well, it's not quite living up to its potential. Time to get drastic, and with drastic measures, there are tradeoffs to consider. These optimizations are going to make your code less modular, harder to understand, and more difficult to maintain. They may cause unexpected side effects like code bloat. Your compiler may not even be able to handle some of the more advanced template-based techniques. Proceed with caution. Arm yourself with a good profiler.

A good compiler can have a huge effect on code performance. Most PC compilers are good, but not great, at optimization. Be aware that sometimes the compiler won't perform optimizations even though it can. The compiler assigns a higher priority to producing consistent and correct code than optimizing performance. Be thankful for small favors.

Pete Isensee has worked on products ranging from database software to Internet applications to games. He's even done all three simultaneously, creating multiplayer Internet games at WON.net and Emerald City Technologies. Pete has his degree in Computer Engineering. He's been programming in C since 1986 and in C++ since 1993, focusing on class design, templates, robustness and optimization technology.

Special thanks to Brian Fiete, Melanie McClaire, Brian Ruud, the WON Viper and Titan teams, the HyperBole X-Files engineering team, my favorite gurus Steve McConnell and Scott Meyers, and my favorite girls Kristi, Ali and Tayla.