Cluster:Gprof - Revision history

Charliep at 00:02, 27 March 2015

2015-03-27T00:02:38Z

← Older revision		Revision as of 00:02, 27 March 2015
Line 17:		Line 17:
	# Run your program, creating gmon.out Your program must terminate with <code>exit(0)</code> or <code>return(0)</code> for gmon.out to be created.		# Run your program, creating gmon.out Your program must terminate with <code>exit(0)</code> or <code>return(0)</code> for gmon.out to be created.
	# Run gprof using the gmon.out file from the previous step as input:		# Run gprof using the gmon.out file from the previous step as input:
	$ gprof --line --annotated-source --flat-profile ~~--graph~~ <binary> gmon.out		$ gprof --line --annotated-source --flat-profile <binary> gmon.out

	A brief summary of the command line options used:		A brief summary of the command line options used:
Line 23:		Line 23:
	* <code>--annotated-source</code> - print annotated source code		* <code>--annotated-source</code> - print annotated source code
	* <code>--flat-profile</code> - print a flat profile		* <code>--flat-profile</code> - print a flat profile
	* <code>--graph</code> - causes the call graph of the program to be augmented with data from the text space of the object file		* <code>--graph</code> - causes the call graph of the program to be augmented with data from the text space of the object file (assumes that there is a call graph, there won't be if there aren't any (local) function calls)

	Line-by-line profiling tends to magnify statistical errors if there isn't enough run-time data. If you use this option be sure you are collecting enough data by having sufficiently large input to your program. gprof supports many options, read the man page for more information about them.		Line-by-line profiling tends to magnify statistical errors if there isn't enough run-time data. If you use this option be sure you are collecting enough data by having sufficiently large input to your program. gprof supports many options, read the man page for more information about them.

Charliep: /* Basic Recipe */

2014-04-25T14:46:21Z

Basic Recipe

← Older revision		Revision as of 14:46, 25 April 2014
Line 14:		Line 14:
	# Compile your program with the <code>-pg -g</code> options, something like so:		# Compile your program with the <code>-pg -g</code> options, something like so:
	$ gcc -pg -g ... -o <binary>		$ gcc -pg -g ... -o <binary>
	# If you link your program separately from compiling it be sure to include the ~~<code>-pg</code> option there as well:~~		# If you link your program separately from compiling it be sure to include the ld mojo to provide the appropriate startup library.
	$ ld ~~-pg~~ .~~.. -o <binary>~~
	# Run your program, creating gmon.out Your program must terminate with <code>exit(0)</code> or <code>return(0)</code> for gmon.out to be created.		# Run your program, creating gmon.out Your program must terminate with <code>exit(0)</code> or <code>return(0)</code> for gmon.out to be created.
	# Run gprof using the gmon.out file from the previous step as input:		# Run gprof using the gmon.out file from the previous step as input:

Charliep: /* Basic Recipe */

2010-03-20T00:41:14Z

Basic Recipe

← Older revision		Revision as of 00:41, 20 March 2010
Line 31:		Line 31:

	# Compile and link your program as above.		# Compile and link your program as above.
	# Run your program say times, using different input and renaming the gmon.out files between each iteration:		# Run your program say times, using different input and renaming the gmon.out files between each iteration (this for loop syntax assumes the Bash shell under Linux):
	$ for x in 1..10; do ./matmul-blocked --infile matmul-$x.dat; mv gmon.out gmon.out.$x; done		$ for x in {1..10}; do ./matmul-blocked --infile matmul-$x.dat; mv gmon.out gmon.out.$x; done
	# Run gprof using the gmon.out.* files from the previous step as input:		# Run gprof using the gmon.out.* files from the previous step as input:
	$ gprof --line --annotated-source --flat-profile --graph <binary> gmon.out.*		$ gprof --line --annotated-source --flat-profile --graph <binary> gmon.out.*

	This technique can also be useful with the same input stream, or a variety of input streams repeated. In both cases more data collected yields a more accurate analysis.		This technique can also be useful with the same input stream, or a variety of input streams repeated. In both cases more data collected yields a more accurate analysis.

	==== More Information ====		==== More Information ====

Charliep at 12:31, 19 March 2010

2010-03-19T12:31:44Z

← Older revision		Revision as of 12:31, 19 March 2010
Line 21:		Line 21:

	A brief summary of the command line options used:		A brief summary of the command line options used:
	* <code>--line</code>		* <code>--line</code> - enables line-by-line profiling
	* <code>--annotated-source</code>		* <code>--annotated-source</code> - print annotated source code
	* <code>--flat-profile</code>		* <code>--flat-profile</code> - print a flat profile
	* <code>--graph</code>		* <code>--graph</code> - causes the call graph of the program to be augmented with data from the text space of the object file

	gprof supports many options, read the man page for more information about them.		Line-by-line profiling tends to magnify statistical errors if there isn't enough run-time data. If you use this option be sure you are collecting enough data by having sufficiently large input to your program. gprof supports many options, read the man page for more information about them.

	If the nature of the input changes the runtime characteristics of your code you can run it many times using a range of different inputs, saving each gmon.out file as it is created, and then have gprof analyze the whole lot of them in one fell swoop. In this mode gprof will combine the data in the run output files into one set of reports showing the sum of the runtime behaviors.		If the nature of the input changes the runtime characteristics of your code you can run it many times using a range of different inputs, saving each gmon.out file as it is created, and then have gprof analyze the whole lot of them in one fell swoop. In this mode gprof will combine the data in the run output files into one set of reports showing the sum of the runtime behaviors.

Charliep at 04:09, 19 March 2010

2010-03-19T04:09:45Z

← Older revision		Revision as of 04:09, 19 March 2010
Line 1:		Line 1:
	== Using gprof ==		== Using gprof ==
	* software-type profiler
	* software-package gprof
	* software-platform Linux-2.6.9-34-x86_64-GNU/Linux-RHEL_AS4, Linux-generic
	* module-version 1.0

	==== Overview ====		==== Overview ====
	gprof is a statistical profiler, that is it derives the information it provides by recording the address in the program counter at regular intervals over the course of a run and then reconstructing the call tree and displaying the results. gprof is part of the GNU toolchain and depends on gcc and ld to create a binary with particular characteristics.		gprof is a statistical profiler, that is it derives the information it provides by recording the address in the program counter at regular intervals over the course of a run and then reconstructing the call tree and displaying the results. gprof is part of the GNU toolchain and depends on gcc and ld to create a binary with particular characteristics.

	gprof is good for finding the 20% of your program where 80% of the time is being spent. It's hard to directly pinpoint particular lines with gprof, or why the code is spending so much time there (I/O, long instruction stream, etc.), but you will know exactly where to concentrate on during a more detailed analysis.		gprof is good for finding the 20% of your program where 80% of the time is being spent. It's hard to directly pinpoint particular lines with gprof, or why the code is spending so much time there (I/O, long instruction stream, etc.), but you will know exactly where to concentrate on during a more detailed analysis.

	Using gprof is a three step process, first the binary is compiled and linked with gcc using options that signal the runtime to collect statistical information. Then the program is run one or more times, each time creating a gmon.out file with run-time information. gprof is then run against the gmon.out file(s) producing one or more reports of the runtime behavior.		Using gprof is a three step process, first the binary is compiled and linked with gcc using options that signal the runtime to collect statistical information. Then the program is run one or more times, each time creating a gmon.out file with run-time information. gprof is then run against the gmon.out file(s) producing one or more reports of the runtime behavior.
Line 48:		Line 43:
	gcov, also part of the GNU toolchain, analyzes runtime data for code coverage. Using gcov and gprof together can yield additional insight into the software under examination.		gcov, also part of the GNU toolchain, analyzes runtime data for code coverage. Using gcov and gprof together can yield additional insight into the software under examination.

	There are many statistical and statement level profilers available. You should almost always start with whatever tool(s) are available with the development toolchain you are using; GNU, Intel, Portland Group, etc. all provide profilers for use with their kits.		There are many statistical and statement level profilers available. You should almost always start with whatever tool(s) are available with the development toolchain you are using; GNU, Intel, Portland Group, etc. all provide profilers for use with their kits.

			==== Module Metadata ====
			* software-type profiler
			* software-package gprof
			* software-platform Linux-2.6.9-34-x86_64-GNU/Linux-RHEL_AS4, Linux-generic
			* module-version 1.0

Charliep: /* Overview */

2010-03-19T04:08:27Z

Overview

← Older revision		Revision as of 04:08, 19 March 2010
Line 7:		Line 7:
	==== Overview ====		==== Overview ====
	gprof is a statistical profiler, that is it derives the information it provides by recording the address in the program counter at regular intervals over the course of a run and then reconstructing the call tree and displaying the results. gprof is part of the GNU toolchain and depends on gcc and ld to create a binary with particular characteristics.		gprof is a statistical profiler, that is it derives the information it provides by recording the address in the program counter at regular intervals over the course of a run and then reconstructing the call tree and displaying the results. gprof is part of the GNU toolchain and depends on gcc and ld to create a binary with particular characteristics.

			gprof is good for finding the 20% of your program where 80% of the time is being spent. It's hard to directly pinpoint particular lines with gprof, or why the code is spending so much time there (I/O, long instruction stream, etc.), but you will know exactly where to concentrate on during a more detailed analysis.

	Using gprof is a three step process, first the binary is compiled and linked with gcc using options that signal the runtime to collect statistical information. Then the program is run one or more times, each time creating a gmon.out file with run-time information. gprof is then run against the gmon.out file(s) producing one or more reports of the runtime behavior.		Using gprof is a three step process, first the binary is compiled and linked with gcc using options that signal the runtime to collect statistical information. Then the program is run one or more times, each time creating a gmon.out file with run-time information. gprof is then run against the gmon.out file(s) producing one or more reports of the runtime behavior.

Charliep: New page: == Using gprof == * software-type profiler * software-package gprof * software-platform Linux-2.6.9-34-x86_64-GNU/Linux-RHEL_AS4, Linux-generic * module-version 1.0 ==== Overview ==== gp...

2010-03-19T04:05:59Z

New page: == Using gprof == * software-type profiler * software-package gprof * software-platform Linux-2.6.9-34-x86_64-GNU/Linux-RHEL_AS4, Linux-generic * module-version 1.0 ==== Overview ==== gp...

New page

== Using gprof ==
* software-type profiler
* software-package gprof
* software-platform Linux-2.6.9-34-x86_64-GNU/Linux-RHEL_AS4, Linux-generic
* module-version 1.0

==== Overview ====
gprof is a statistical profiler, that is it derives the information it provides by recording the address in the program counter at regular intervals over the course of a run and then reconstructing the call tree and displaying the results. gprof is part of the GNU toolchain and depends on gcc and ld to create a binary with particular characteristics.

Using gprof is a three step process, first the binary is compiled and linked with gcc using options that signal the runtime to collect statistical information. Then the program is run one or more times, each time creating a gmon.out file with run-time information. gprof is then run against the gmon.out file(s) producing one or more reports of the runtime behavior.

gprof is part of the GNU toolchain. More information about gprof and the GNU project is available at http://gnu.org.

==== Basic Recipe ====
These commands should work on any "modern" Linux distro. In all the example command lines the $ is not part of the command, it's the indicator that these are to be typed at a shell prompt.

# Compile your program with the <code>-pg -g</code> options, something like so:
$ gcc -pg -g ... -o <binary>
# If you link your program separately from compiling it be sure to include the <code>-pg</code> option there as well:
$ ld -pg ... -o <binary>
# Run your program, creating gmon.out Your program must terminate with <code>exit(0)</code> or <code>return(0)</code> for gmon.out to be created.
# Run gprof using the gmon.out file from the previous step as input:
$ gprof --line --annotated-source --flat-profile --graph <binary> gmon.out

A brief summary of the command line options used:
* <code>--line</code>
* <code>--annotated-source</code>
* <code>--flat-profile</code>
* <code>--graph</code>

gprof supports many options, read the man page for more information about them.

If the nature of the input changes the runtime characteristics of your code you can run it many times using a range of different inputs, saving each gmon.out file as it is created, and then have gprof analyze the whole lot of them in one fell swoop. In this mode gprof will combine the data in the run output files into one set of reports showing the sum of the runtime behaviors.

# Compile and link your program as above.
# Run your program say times, using different input and renaming the gmon.out files between each iteration:
$ for x in 1..10; do ./matmul-blocked --infile matmul-$x.dat; mv gmon.out gmon.out.$x; done
# Run gprof using the gmon.out.* files from the previous step as input:
$ gprof --line --annotated-source --flat-profile --graph <binary> gmon.out.*

This technique can also be useful with the same input stream, or a variety of input streams repeated. In both cases more data collected yields a more accurate analysis.

==== More Information ====
The man page is worth reading, it's not particularly long and includes a detailed description of how gprof works.

gcov, also part of the GNU toolchain, analyzes runtime data for code coverage. Using gcov and gprof together can yield additional insight into the software under examination.

There are many statistical and statement level profilers available. You should almost always start with whatever tool(s) are available with the development toolchain you are using; GNU, Intel, Portland Group, etc. all provide profilers for use with their kits.