gprof - Unix, Linux Command

NAME

SYNOPSIS

DESCRIPTION

Gprof calculates the amount of time spent in each routine. Next, these times are propagated along the edges of the call graph. Cycles are discovered, and calls into a cycle are made to share the time of the cycle.

Several forms of output are available from the analysis.

The flat profile shows how much time your program spent in each function, and how many times that function was called. If you simply want to know which functions burn most of the cycles, it is stated concisely here.

The call graph shows, for each function, which functions called it, which other functions it called, and how many times. There is also an estimate of how much time was spent in the subroutines of each function. This can suggest places where you might try to eliminate function calls that use a lot of time.

The annotated source listing is a copy of the program’s source code, labeled with the number of times each line of the program was executed.

OPTIONS

Many of these options take an optional symspec to specify functions to be included or excluded. These options can be specified multiple times, with different symspecs, to include or exclude sets of symbols.

Specifying any of these options overrides the default (-p -q), which prints a flat profile and call graph analysis for all functions.

        c-parse.o:00000000 T yyparse
        c-parse.o:00000004 C yyerrflag
        c-lang.o:00000000 T maybe_objc_method_name
        c-lang.o:00000000 T print_lang_statistics
        c-lang.o:00000000 T recognize_objc_keyword
        c-decl.o:00000000 T print_lang_identifier
        c-decl.o:00000000 T print_lang_type
        ...

Analysis Options

Miscellaneous Options

Deprecated Options

FILES

EXAMPLES

Consider below program for which you need to generate profiling data: TestGprof.c

#include<stdio.h>

void TestFunc();
static void StaticFunc();

void TestFunc()
{
        int i = 0;

        printf("In TestFunc\n");

        for (i=0; i<100; i++)
                StaticFunc();

}

static void StaticFunc()
{
        int i = 0;

        printf("In StaticFunc\n");

        for (i=0; i<100000000; i++);
}

int main(void)
{
        printf("In main\n");

        TestFunc();

        return 0;
}

Step 1. Enable profiling during compilation (use -pg option)

$ gcc -pg -o TestGprof TestGprof.c

Step 2. Execute the binary so that profiling data is generated

$ ./TestGprof

If the profiling is enabled then on executing the program, file gmon.out will be generated.

$ ls
gmon.out  TestGprof  TestGprof.c

Step 3. Run gprof on profiling data

$ gprof -b TestGprof gmon.out > analysis.out

This will give an human readable file. This file contains two tables:
flat profile: overview of the timing information of the functions
call graph: focuses on each function

-b option will suppress lot of verbose information which would be otherwise included in analysis file.

Below are the contents of analysis.out

Flat profile:

Each sample counts as 0.01 seconds.
  %   cumulative   self              self     total
 time   seconds   seconds    calls   s/call   s/call  name
100.55     20.38    20.38      100     0.20     0.20  StaticFunc
  0.00     20.38     0.00        1     0.00    20.38  TestFunc

                        Call graph


granularity: each sample hit covers 2 byte(s) for 0.05% of 20.38 seconds

index % time    self  children    called     name
               20.38    0.00     100/100         TestFunc [2]
[1]    100.0   20.38    0.00     100         StaticFunc [1]
-----------------------------------------------
                0.00   20.38       1/1           main [3]
[2]    100.0    0.00   20.38       1         TestFunc [2]
               20.38    0.00     100/100         StaticFunc [1]
-----------------------------------------------
                                                 
[3]    100.0    0.00   20.38                 main [3]
                0.00   20.38       1/1           TestFunc [2]
-----------------------------------------------

Index by function name

   [1] StaticFunc              [2] TestFunc

Below are few more examples of gprof options

Suppress printing statically declared functions with -a option

$ gprof -b -a TestGprof gmon.out > analysis.out

Print only flat profile using -p option

$ gprof -b -p TestGprof

Print info related to specific function

$ gprof -b -pStaticFunc TestGprof

Suppress printing of flat profile using -P option

$ gprof -b -P TestGprof

Print only call graph using -q option

$ gprof -b -q TestGprof

Suppress printing of call graph using -Q option

$ gprof -b -Q TestGprof