如何使用 KCachegrind 和 Callgrind 仅测量我的代码的一部分？

Question

I want to use valgrind to analyze my code. The problem is, that I have a huge startup sequence which I'm not interested in.

I found defines in the valgrind/callgrind.h that should help me:

• CALLGRIND_START_INSTRUMENTATION
• CALLGRIND_STOP_INSTRUMENTATION
• CALLGRIND_DUMP_STATS

According to this article I have to execute valgrind with the following options:

valgrind --tool=callgrind --instr-atstart=no ./application

When I do this two files are created:

• callgrind.out.16060
• callgrind.out.16060.1

I then want to use kcachegrind to visualize my results. This works great but the makros for the skipping of my startup-sequence seem to do nothing. What do I have to do to measure the performance only in places where I want to?

Answer 1

I got it now, but I'm not 100% sure why. I will try to describe my code a bit:

I have an Application class that is responsible for a lot of subsystems. In my original attempt I tried to measure the performance inside the Application like this:

int main(int argc, char *argv[])
{
    Application a(argc, argv);
    return a.exec();
}

void Application::Application(int &argc, char **argv)
{
    m_pComplexSystem = new ComplexSystem();
    m_pComplexSystem->configure();

    CALLGRIND_START_INSTRUMENTATION;
    m_Configurator->start();    
}

Application::~Application()
{
    CALLGRIND_STOP_INSTRUMENTATION;
    CALLGRIND_DUMP_STATS;
    m_pComplexSystem ->stop();

    delete m_pComplexSystem;
    m_pComplexSystem = 0;
}

For some reason the defines were ignored and I got the performance measures of the whole constructor and everything that was done in the configure() call of the ComplexSystem member.

So now I use this code that seems to work:

int main(int argc, char *argv[])
{
    Application a(argc, argv);

    CALLGRIND_START_INSTRUMENTATION;
    int result = a.exec();
    CALLGRIND_STOP_INSTRUMENTATION;
    CALLGRIND_DUMP_STATS;
    return result;
}

Although it is not exactly the same as my original attempt, I can start looking for slow functions now.

Answer 2

Let's assume you have the following open-source program:

int main()
{
    function1();

    function2();
    
    return 0;
}

Let's assume you want to execute Callgrind on only function2() .

One approach is to insert Callgrind macros around function2() , and do the recompilation of the program (please compare with the above):

#include <valgrind/callgrind.h>
int main()
{
    function1();

    CALLGRIND_START_INSTRUMENTATION;
    CALLGRIND_TOGGLE_COLLECT;
        function2();
    CALLGRIND_TOGGLE_COLLECT;
    CALLGRIND_STOP_INSTRUMENTATION;

    return 0;
}

In some cases, callgrind.h may not be found, see here for a similar problem . The likely solution is to install/compile valgrind-devel , see this answer .

Finally, you will need to add two new options to your callgrind commands, eg:

valgrind --tool=callgrind \
    --collect-atstart=no --instr-atstart=no \ #new options
    <program>

This answer is an extension of this entry .