How To Profile A C Program In Linux Using Gnu Gprof

Profiling a C Program in Linux Using GNU Gprof

Profiling is a crucial step in optimizing the performance of C programs, allowing developers to identify and improve the most time-consuming parts of their code. GNU Gprof is a powerful profiling tool that helps in analyzing the execution time of C programs, making it easier to optimize them.

Compiling the Program for Profiling

To use Gprof, you need to compile your C program with the -pg option. This option instructs the compiler to generate extra code that collects profiling information during the execution of the program. Here is how you can compile your program:

$ gcc -Wall -pg test_gprof.c test_gprof_new.c -o test_gprof

The -pg option must be used during both the compilation and linking steps. This ensures that the necessary instrumentation is included in the final executable.

Executing the Program

After compiling the program with the -pg option, you need to execute it to generate the profiling data. When you run the program, it will create a file named gmon.out in the current working directory, which contains the raw profiling data.

$ ./test_gprof
$ ls
test_gprof  test_gprof.c  test_gprof_new.c  gmon.out

Note that if your program changes the current working directory using chdir, the gmon.out file will be created in the new directory. Also, ensure that the program has sufficient permissions to create the gmon.out file in the desired directory.

Running Gprof

Once the gmon.out file is generated, you can run Gprof to analyze the profiling data. The basic command to run Gprof is:

$ gprof test_gprof gmon.out > analysis.txt

This command will produce a detailed analysis of the profiling data and save it to analysis.txt. If you do not specify the output file, the analysis will be displayed on the standard output.

Understanding Gprof Output

Gprof produces two main types of output: the flat profile and the call graph.

Flat Profile

The flat profile shows how much time your program spent in each function and how many times each function was called. This is useful for identifying which functions are consuming the most CPU time. Here is an example of what the flat profile might look like:

%   cumulative   self              self     total
time   seconds   seconds    calls  ms/call  ms/call  name
80.01    0.12    0.00        1     0.00     0.00  func1
15.00    0.18    0.06        1    60.00    60.00  func2

This output indicates the percentage of CPU time spent in each function, the cumulative time, the self time (time spent in the function itself), the number of calls, and the time per call.

Call Graph

The call graph shows which functions called which other functions and how many times these calls were made. This helps in understanding the flow of your program and identifying performance bottlenecks in the function call hierarchy.

Advanced Options and Features

Suppressing Private Functions

If you want to suppress the printing of statically declared (private) functions, you can use the -a option with Gprof:

$ gprof -a test_gprof gmon.out > analysis.txt

This option is useful when you are not interested in the profiling information of private functions.

Line-by-Line Profiling

For more detailed profiling, you can use the -g option along with -pg to include debugging symbols that match program addresses to source code lines. This allows for line-by-line profiling:

$ gcc -Wall -pg -g test_gprof.c test_gprof_new.c -o test_gprof

This will enable Gprof to construct an annotated source code listing showing how many times each line of code was executed.

Basic-Block Counting

You can also use the -a option to instrument the program for basic-block counting. This will count how many times each branch of each if statement, each iteration of each do loop, etc., was executed:

$ gcc -Wall -pg -a test_gprof.c test_gprof_new.c -o test_gprof

This feature helps in constructing an annotated source code listing that shows the execution count for each line of code.

Common Pitfalls and Considerations

Permissions: Ensure that the program has sufficient permissions to create the gmon.out file in the desired directory.
Directory Changes: If your program changes the current working directory using chdir, the gmon.out file will be created in the new directory.
Incomplete Information: If only some modules of the program are compiled with the -pg option, you will not get complete information about the modules that were compiled without it. This affects the call graph but not the flat profile.
Input and Arguments: The way you run the program and the input you provide can significantly affect the profiling results. Ensure that you run the program with representative input to get meaningful profiling data.

By following these steps and considering these advanced features and pitfalls, you can effectively use Gprof to optimize your C programs and improve their performance.