List of common C++ Optimization Techniques [closed]

Answer 1

1. Profile your code to find what's actually taking the most time
2. Make sure you're using the right algorithm
3. If you're doing a lot of number crunching, be friendly with your cache and try to do everything possible on a chunk of data all at once so it doesn't have to be loaded into cache many times.

Answer 2

Sorry I don't have any references for you, but I do have another anecdote to add to the pile.

I had a rather large std::map that I was generating using Microsoft's CString object as the key. Performance was unacceptable. Since all of my strings were identical in length, I created a class wrapper around an old-fashioned fixed-size array of chars, to emulate the interface of CString. Unfortunately I can't remember the exact speedup, but it was significant, and the resulting performance was more than adequate.

Sometimes you need to know a little about the library constructs you rely upon.

Answer 3

Agner Fog has done a great job analyzing the output of several compilers regarding C++ constructs. You will find his work here: http://www.agner.org/optimize/.

Intel offers a great document too - the "Intel® 64 and IA-32 Architectures Optimization Reference Manual", which you will find at http://www.intel.com/products/processor/manuals/index.htm. Although it mainly targets IA-32 architectures, it contains general advice that can be applied on most platforms. Obviously, it and Agner Fog's guide do intersect a bit.

As mentioned in other answers, micro-optimization is obviously the last step you want take to make your program faster, after profiling and algorithm selection.

Answer 4

I will echo what others have said: a better algorithm is going to win in terms of performance gains.

That said, I work in image processing, which as a problem domain can be stickier. For example, many years ago I had a chunk of code that looked like this:

void FlipBuffer(unsigned char *start, unsigned char *end)
{
    unsigned char temp;

    while (start <= end) {
        temp = _bitRev[*start];
        *start++ = _bitRev[*end];
        *end-- = temp;
    }
 }

which rotates a 1-bit frame buffer 180 degrees. _bitRev is a 256 byte table of reversed bits. This code is about as tight as you can get it. It ran on an 8MHz 68K laser printer controller and took roughly 2.5 seconds for a legal sized piece of paper. To spare you the details, the customer couldn't bear 2.5 seconds. The solution was an identical algorithm to this. The difference was that

1. I used a 128K table and operated on words instead of bytes (the 68K is much happier on words)
2. I used Duff's device to unroll the loop as much as would fit within a short branch
3. I put in an optimization to skip blank words
4. I finally rewrote it in assembly to take advantage of the sobgtr instruction (subtract one and branch on greater) and have "free" post increment and pre-decrements in the right places.

So 5x: no algorithm change.

The point is that you also need to understand your problem domain and what bottlenecks means. In image processing, algorithm is still king, but if your loops are doing extra work, multiply that work by several million and that's the price you pay.

Answer 5

There are many things you can do to optimize C++ code. Some of the broader suggestions are listed above.

A couple specific examples are:

1. Using Structs of Arrays as opposed to Array of Structs (Classic example of DOP vs OOP)
2. Using restrict in C++ when you know two pointers will not point to the same memory location

In general, following a fundamental programming paradigm such as Data Oriented Programming will yield higher performance as DOP is specifically formulated to focus on performance (in all forms: memory layouts, cache coherency, runtime costs, etc.)

More info here: https://people.cs.clemson.edu/~dhouse/courses/405/papers/optimize.pdf

Answer 6

You might be interested in this: Optimizing C++ Wikibook