SIGs/PowerManagement/DevelopmentDocumentation

Development Tips

Oprofile

It is often mentioned that running oprofile is more complicated than using gprof, because it has to be started a daemon and loaded a kernel module. But gprof needs recompilation of an application and dependent libraries with -pg option, which could be worse in case you need to recompile also glib library. Setting and using oprofile:

• configuring
• controlling

Best practices

In every good course book are mentioned problems with memory allocation, performance of some specific functions and so on. The best thing what to do is buy a good book ;-)

Here is a short overview of techniques which are often problematic:

• excessive I/O, power consumption, or memory usage - memleaks
• threads
• Avoid unnecessary work/computation
• Wake up only when necessary
• Do not actively poll in programs or use short regular timeouts, rather react to events
• If you wake up, do everything at once (race to idle) and as fast as possible
• Use large buffers to avoid frequent disk access. Write one large block at a time
• Don't use [f]sync() if not necessary
• Group timers across applications if possible (even systems)

And now some examples:

Threads

It is widely belived that using threads make our application performing better and faster. But it is not true everytime. Python is using Global Lock Interpreter so the threading is profitable only for bigger I/O operations. We can help threads by optimizing them by unladded swallow (still not in upstream).

Perl threads were created for application which run on systems without fork (win32). In Perl are data by default copied for every thread (Copy On Write) and if user includes module for sharing data ([ threads::shared]), then are data copied (Copy On Write) plus it creates tied variables, which takes even more time. It has pros and cons but definitely one should think about usage and run some performance tests.

In C threads share the same memory, each thread has his own stack, kernel doesn't have to create new file descriptors and allocate new memory space. Threads are taking advantage from more CPUs.