Qt/Embedded Performance Tuning

Static vs. Dynamic Linking

A lot of CPU and memory is used by the ELF linking process. You can make significant savings by using a static build of your application suite. This means that rather than having dynamic Qt libraries and a collection of executables which link dynamically to these libraries, you build all the applications into a single executable and statically link that with static Qt libraries. This improves start-up time, and reduces memory usage, at the expense of flexibility (to add a new application, you must recompile the single executable) and robustness (if one application has a bug, it might harm other applications). If you need to install end-user applications, this may not be an option, but if you are building a single application suite for a device with limited CPU power and memory, this option could be very beneficial.

To compile Qt as a static library, use the -static option when you run configure.

To build your application suite as an all-in-one application, design each application as a stand-alone widget or set of widgets, with only minimal code in the main() function. Then, write an application that provides a means of switching between the applications (e.g. a QIconView). The Qtopia is an example of this. It can be built either as a set of dynamically linked executables, or as a single static application.

Note that you should generally still link dynamically against the standard C library and any other libraries which might be used by other applications on your device.

    void *operator new[](size_t size)
    {
        return malloc(size);
    }

    void *operator new(size_t size)
    {
        return malloc(size);
    }

    void operator delete[](void *ptr)
    {
        free(ptr);
    }

    void operator delete[](void *ptr, size_t)
    {
        free(ptr);
    }

    void operator delete(void *ptr)
    {
        free(ptr);
    }

    void operator delete(void *ptr, size_t)
    {
        free(ptr);
    }