Linux C + + program Profiling Tools Gprof Getting Started with

Performance analysis Tools

Software performance is an important point of inspection of software quality, whether online service programs or offline programs, or even terminal applications, performance is the key to user experience. There are two aspects of performance and stability that are mentioned in the major performance areas, and we have to focus on testing the performance and stability of the version when we do software testing. There are many ways to locate the performance problems found during software testing. The basic approach might be for developers to review the code, or to use some tools to perform profiling of the code. What are the common performance analysis tuning tools? The following two articles make a detailed summary:

• https://computing.llnl.gov/tutorials/performance_tools/#Considerations
• Http://en.wikipedia.org/wiki/List_of_performance_analysis_tools

In my work is mainly about the Linux C + + program code performance analysis, GPROF is available for Linux C + + code performance profiling one of the tools, this article mainly talk about my study of gprof and use of the process.

The basic principle of gprof

Gprof lets you know where your code is time-consuming, what functions are called many times, and allows you to see the call relationship between functions and functions at a glance. Gprof is a performance diagnostic tool supported by the gcc/g++ compiler. As long as the-PG option is added at compile time, the compiler will add a Mcount function call at the beginning of each function at compile time, call this mcount function before each function call, save the call graph of the function and the call time of the function and the number of times in the Mcount. Finally, when the program exits in the Gmon.out file, it is important to note that the program must exit normally or exit by exit, because the program writes the Gmon.out file whenever exit () is called.

Then, the use of gprof is mainly the following three steps:

• The program is compiled with the-PG parameter
• Run the program and exit normally
• View Gmon.out File

Gprof Use Instances

2. #include <iostream>
4. Using namespace std;
8. int Add (int A, int b)
10. {
12. return a+b;
14. }
18. int sub (int A, int b)
20. {
22. return a-B;
24. }
28. int call ()
30. {
32. Std::cout << Add (+) << Std::endl;
34. Std::cout << Sub (2,4) << Std::endl;
36. }
40. int main ()
42. {
44. int a=1, b=2;
46. cout << Add (A, b) << Endl;
48. For (int i=0; i<10000; i++)
50. Call ();
52. return 0;
54. }

Compile with g++ and add the-PG parameter:

1. g++-O Hello hello_grof.cpp-pg-g

To get the executable file, we can use readelf to see what the difference is between its symbol table and what was compiled without-PG: Readelf-r./hello and Readelf-r./hello_normal results.

The left side is the result of compiling with the-PG parameter. You can see that there are three more function symbols _mcount, __monstartup, _mcleanup are calls related to Gprof.

Using GDB to debug the Hello program, the break point in the Mcount function can also see its invocation relationship, and the Mcount function is called before the Add function executes:

Next, run the program./hello, which generates the Gmon.out file in the current directory. To view file information using Gprof:

1. Gprof-b./hello gmon.out

Get the following output:

2. Flat Profile:
6. Each sample counts as 0.01 seconds.
8. No time accumulated
12. % cumulative self to total
14. Time seconds seconds calls Ts/call Ts/call name
16. 0.00 0.00 0.00 10001 0.00 0.00 Add (int, int)
18. 0.00 0.00 0.00 10000 0.00 0.00 Sub (int, int)
20. 0.00 0.00 0.00 10000 0.00 0.00 Call ()
22. 0.00 0.00 0.00 1 0.00 0.00 Global Constructors keyed to _z3addii
24. 0.00 0.00 0.00 1 0.00 0.00 __STATIC_INITIALIZATION_AND_DESTRUCTION_0 (int, int)
28. Call graph
34. Granularity:each sample hit covers 2 byte (s) No time propagated
38. Index% time self children called name
40. 0.00 0.00 1/10001 Main [7]
42. 0.00 0.00 10000/10001 Call () [10]
44. [8] 0.0 0.00 0.00 10001 Add (int, int) [8]
46. -----------------------------------------------
48. 0.00 0.00 10000/10000 Call () [10]
50. [9] 0.0 0.00 0.00 10000 SUB (int, int) [9]
52. -----------------------------------------------
54. 0.00 0.00 10000/10000 Main [7]
56. [Ten] 0.0 0.00 0.00 10000 Call () [10]
58. 0.00 0.00 10000/10001 Add (int, int) [8]
60. 0.00 0.00 10000/10000 Sub (int, int) [9]
62. -----------------------------------------------
64. 0.00 0.00 1/1 __do_global_ctors_aux [13]
66. [One] 0.0 0.00 0.00 1 Global Constructors keyed to _z3addii [11]
68. 0.00 0.00 1/1 __STATIC_INITIALIZATION_AND_DESTRUCTION_0 (int, int) [12]
70. -----------------------------------------------
72. 0.00 0.00 1/1 Global Constructors keyed to _z3addii [11]
74. [0.0] 0.00 0.00 1 __STATIC_INITIALIZATION_AND_DESTRUCTION_0 (int, int) [12]
76. -----------------------------------------------
80. Index by Function name
84. [One] global constructors keyed to _z3addii (hello_grof.cpp) [9] Sub (int, int) [Ten] Call ()
86. [8] Add (int, int) [__STATIC_INITIALIZATION_AND_DESTRUCTION_0] (int, int) (HELLO_GROF.CPP)

You can use the Run command:

1. Gprof-b./hello Gmon.out | gprof2doc.py > ~www/hello.dot

To generate a call graph file in dot format, you can use the Windows version of Gvedit for Graphviz software to view the call graph:

Attach a more complex program call graph:

For call relationships and call hotspots at a glance.

Gprof Output Interpretation

This section removes the-b parameter in Gprof-b./hello and displays a detailed description of what the field means:

2. The percentage of the total running time of the
4. Used by this function.
6. 16
8. Cumulative a running sum of the number of seconds accounted
10. seconds for by this function and those listed above it.
12. 19
14. Self the number of seconds accounted
16. seconds function alone. The major sort for this
18. Listing.
20. 23
22. Calls the number of times this function is invoked, if
24. This function is profiled, else blank.
26. 26
28. The average number of milliseconds spent in this
30. Ms/call function per call, if the function is profiled,
32. else blank.
34. 30
36. Total the average number of milliseconds spent in this
38. Ms/call function and its descendents per call, if this
40. The function is profiled, else blank.
42. 34
44. The name of the function. This is the minor sort
46. Listing. The index shows the location of
48. PNS the function in the GPROF listing. If the index is
50. Parenthesis in the It shows where it would appear in
52. The GPROF listing if it were to be printed.

Summarize

Gprof is a common profiling tool that lists some of its shortcomings and is also viewed from the Web:

• 1, the multi-threaded support is not good, inaccurate
• 2. Must exit Exit ()
• 3. It can only analyze the user time consumed by the application during operation, and cannot get the running time of the program kernel space. There is nothing to call analysis of the kernel state. If the program system call ratio is relatively large, it is not appropriate.

Linux C + + programs for Profiling Tools Gprof Getting Started