I found some references which maybe can help you:

Automatic Tuning of Compiler Optimizations and Analysis of their Impact      DOI:10.1016/j.procs.2013.05.298

A compiler infrastructure for embedded heterogeneous MPSoCs      DOI:10.1016/j.parco.2013.11.007

A practical solution for achieving language compatibility in scripting language compilers    DOI:10.1016/j.scico.2011.01.004

Synthesizing testability features into a design with the Synopsys Test Compiler      DOI: 10.1109/WESCAN.1995.494074 

Agree with all of the comments by Peter, but the next step is to perform profiling on the compiled (with debug options, i.e., not stripped of symbols) and determine what functions or procedures are used for most of the time during execution. Then concentrate on algorithmic improvement of those subroutines -- might involve using specific compiler switches on the code in a separate source file.

Hi dear peter,

I wanna use qt 5 (and C++) for developing and compiling my code for android. Insomuch, my code is heavy to run for android, I wanna tuning my compiler features to run my code fast as fast possible, but I have not any knowledge about this.

Hi dear leonard, 

I read first paper, "Automatic Tuning of Compiler Optimizations and Analysis of their Impact". This is good for me. But where I can download the tools that introduced in this paper? Are you have this tools?

heavy means: more process to run, such as reading video, process frames, ....

:d

As Peter has already mentioned there are compiler switches to turn on different levels of optimization. But, the most serious problem is how you write your code. Certain things are slow in the way you write them in C++. From my experience Qt is not the real problem. A lot of times I found their data structures to be a lot faster (sometimes factor of 3) than the GNU STL.

However, it is not true that C++ is always slower than C. It is in the hands of the programmer if C++ is slower or faster than a comparable C solution. Most importantly, it is also in the programmer's hand how much of the code can be inlined. Inlining of functions can be achieved in several ways. Small methods you should always define where they are declared in the header file. This allows for heavy inlining and optimization of one-liners. This is especially true if you learned "good" principals of software engineering: Using getters and setters for all members like this:

class A {

    int x;public:

    int getX() const { return x; }

    void setX(int i) { x = i; }

};

If you put the implementation of the getter and setter in a separate cpp-file they cannot be inlined (unless you compile all files at once, not like most build tools compile files separately and link them later (unless in the latter case you turn on specific link-time optimizations)).

BTW the inventor of C++ has a good point: If you know that you are going to provide public access to a variable through getters and setters, just don't write these methods but instead make the member variable public. This is not good software engineering practice (because some guru said so), but it makes the most sense in C++.

Also, like Peter already mentioned, declare as much variables as const as you can. Do the same for class methods. An example where to use const for methods is in the above example for getX(). Sometimes this even means that you have to write a method twice, once with const and once without const. The reason why to use const is that the compiler can deduce a lot more optimizations from this additional information that a variable will not change. A lot of times I will 'store' data into a const reference because this will avoid copying. If you can use C++11 in your project, then learn about move semantics and use it.

The most important thing about performance is to avoid 'new' and 'delete' (and their C counterparts malloc() and free()) like the plague. Dynamic memory management consumes a lot of time. This will slow your software down because during runtime a piece of memory that is large enough to hold your data has to be found. Instead try to put most variables on the stack. Large data always has to be allocated on the heap. But, here a single allocation of an array can sometimes help. Once allocated reuse it as often as you can.

One place where this is hard to see is when using std::vector or QVector. You can easily place a variable of this type on the stack. But, internally an array will be allocated on the heap. What's even worse is that it automatically grows depending on the use. If you know that you are about to add a 1000 elements to a vector you should let the vector know about that, too. Most people will just call push_back()/append() a 1000 times. The vector class then has to resize the internal array a couple of times. This involves calls to 'new' and 'delete'  whenever the array has to be resized and also the data has to be copied every time. This can be avoided by calling reserve(1000) before putting the elements into the vector. In most implementation this will internally first reserve an array of size of at least 1000 elements. You can put 1000 elements into the vector and it will never resize.

Another place where this problem can come up is in loops. Take this simple example:

A *a;

for(int i = 0; i < n; ++i) {

    a = new A();

    // do some stuff

    delete a;

}

If 'n' is large there will be many calls to 'new' and 'delete'. Maybe you think you are smart and you have learned to put variables on the stack. Then might come up with the following:

for(int i = 0; i < n; ++i) {

    A a;

    // do some stuff

}

This is already a lot better. First of all, there is no direct call to 'new' and 'delete'. And secondly, you cannot forget to call 'delete'. This means there will be no memory leak. One problem here might be that you call the constructor and destructor of 'A' in every loop iteration. Maybe those do a lot of stuff. Maybe they even include calls to 'new' and 'delete' themselves. A better way would be to overload the assignment operator for A (in a slightly different context) and do the following:

A a;   // constructor only called once

for(int i = 0; i < n; ++i) {

    a = b.getSomeValue(i);

    // do some stuff

}

In this case 'a' already has all the resources that it needs inside the loop (this helps if 'A' internally uses 'new' and 'delete'). Also, you avoid calling the destructor in every loop iteration. Most of the time you can even improve the above code:

for(int i = 0; i < n; ++i) {

    const A &a = b.getSomeValue(i);

    // do some stuff

}

For this getSomeValue() should be declared like this:

const A &getSomeValue(int index) const;

Here, we actually have to write the variable 'a' inside the loop because it is just a reference and references cannot be reassigned. If you can use this approach it is the fastest you can get. If additionally getSomeValue() can be inlined the compiler will see the variable you are accessing from 'b' directly wherever you use 'a'. That would be like having no overhead at all.

One last thing where to be careful is the use of 'virtual'. Especially people coming from Java like this feature because it allows dynamic dispatching of method calls like in Java. It is always faster to have static dispatching instead. So, think if you really need 'virtual' modifiers for your methods. In a few cases you do, but in most cases you don't.

In your specific case of handling videos you will get most optimal performance by writing assembler and directly accessing SIMD instructions or maybe even special video decoding hardware. But, depending on you specific task there might be libraries which handle exactly this. So, whenever you can don't try to reinvent the wheel, but use as much existing libraries from people with more experience as possible. If you really have to write your own code (because it is a entirely new algorithm) then getting highly performing code means to learn C++ and assembler for another 10-20 years.

This is only a short overview what you can do better. The best advice I can give is to read books by Herb Sutter and Scott Meyers, e.g. "Effective C++". They will teach you best practices from a programmer's point of view instead of what software engineers will tell you.

Hello Erfan,

for most of the compilers you can only control a limited set of OPTIMIZATION FLAGS. Please see your compiler reference for more information about them. Usually trying -O2 and -O3 and -ffast-math on GCC is a standard thing. If that is not enough for you then go ahead and read the rest of this answer.

I think you are asking a wrong question here. The thing is: the compilers are very complex, but still pretty dumb tools. As far as the optimizing compilers can do some sort of optimizations, there is a very little that can be done in terms of understanding what the programmer had in mind when developing code. Since you are working on an android app, I will assume you are not doing any type of research, but only application development. So the question should be: how can you increase the performance of your application without loosing too much time?

If you are not preparing a mission-critical or HPC application, you should not be focusing that much on the tools that you are using. Yes, you can gain something by modifying compiler flags or by using different libraries, but it is very difficult to measure such things and to have an automatic way of doing so. Instead you should focus on the data structures and algorithms you are using in your application. For that I recommend starting with some classics:

- "Introduction to algorithms" Cormen, Leiserson, Rivest, Stein http://www.amazon.com/Introduction-Algorithms-Edition-Thomas-Cormen/dp/0262033844

- "The art of computer programming" D. Knuth http://www.amazon.com/Computer-Programming-Volumes-1-4A-Boxed/dp/0321751043

- "Programming pearls" J. Bentley http://www.amazon.com/Programming-Pearls-2nd-Edition-Bentley/dp/0201657880

- "Design Patterns: elements of reusable object oriented software" Gamma, Helm, Johnson, Vlissides, http://www.amazon.com/Design-Patterns-Object-Oriented-Professional-Computing/dp/0201634988

- "Patterns for Parallel programming: Mattsson, Sanders, Massingill  http://www.amazon.com/Patterns-Parallel-Programming-paperback-Software/dp/0321940784

Of course implementing all the algorithms yourself is a waste of time, so when you have a good feeling on what algorithms you need, you should use proper libraries. If for example you are doing mathematic calculations then search for libraries that do ALL the stuff that you need instead of having multiple libraries doing separate things. This usually yields better results because you don't have to take care of structures formats.

As for the understanding how c++ constructs can affect performance, you should look at Agner Fog's "Optimizing Software in C++" (http://www.agner.org/optimize/optimizing_cpp.pdf). The rules valid for linux usually apply also for android.If after doing the design and implementation well you are still not getting enough performance, you either have to relax your requirements or go for some expert tools, e.g.: performance autotuning, code quality analysing, profiling etc. But in most cases these tools are not very easy to understand and use and usually not very well documented.

And you should not go into compiler stuff unless you are planning to become compilers expert. In that case there is a one "must-read": "Compiler design: principles, techniques and tools" Aho, Lam, Sethi, Ullman (http://en.wikipedia.org/wiki/Compilers:_Principles,_Techniques,_and_Tools). Mind that the effort you need to understand the details of compiler design will most probably be much higher than one needed for using performance tools. There is a reason why the book is called "dragon book" and not "expert book"...

Przemysław, you have mentioned books about design patterns. From my experience people will start trying to push every design pattern into their software. This will hurt performance badly. Most design patterns are built for reusability and not for performance. In general, these two don't have to contradict each other, but following most of the design patterns from books will usually result in bad performance. (Just to give one example: the PIMPL idiom will hurt performance because it inhibits inlining.)

I also think that performance is critical for Erfan. Not only in HPC is performance optimization of concern. I wish all end user software would be optimized. I want to work with software without any lags. If your software does computationally intensive stuff, you should definitely optimize your software when others are supposed to use it. This is the case for video related software.

Design patterns are only patterns, not laws;] It is always useful to know them, but the application of a specific pattern is a matter of design decision. Do you prefer scalability over performance? Do you have development resources for particular pattern? Do you want code that is easier to debug? And others... I realize this is not a precise answer for the question asked, but i think that learning algorithms have to be followed by learning design patterns. It should always be the designer that consciously chooses specific patterns over others, and that cannot be done without proper knowledge.

As for the performance: I agree, everybody needs it. My answer was more like: go for compiler design and low level code analysis AFTER making sure you have realistic performance expectations from your hardware you are using and AFTER making sure you are using proper algorithms and data representation.