gprof man page on HP-UX

Man page or keyword search:  
man Server   10987 pages
apropos Keyword Search (all sections)
Output format
HP-UX logo
[printable version]

gprof(1)							      gprof(1)

       gprof - display call graph profile data

       [options] [a.out [gmon.out...]]

       The  command  produces  an execution profile of C++, C and FORTRAN pro‐
       grams.  The effect of called routines is incorporated into the  profile
       of each caller.	Profile data is taken from the call graph profile file
       default) that is created by programs compiled with the  option  of  and
       The option also links in versions of the library routines that are com‐
       piled for profiling.

       On Itanium(R)-based systems, supports multiple shared libraries profil‐
       ing.   On  PA-RISC  systems,  supports single shared library profiling.
       For details on this see the section below,

       The symbol table for the load modules being profiled are read and  cor‐
       related	with  the call graph profile file To have the full call graph,
       no load module symbol table may be chopped; that is,  no	 compiles  may
       use  the	 option.   If  more than one profile file is specified, output
       shows the sum of the profile information in the given profile files.

       First, a flat profile is	 given,	 similar  to  that  provided  by  (see
       prof(1)).  This listing gives the total execution times and call counts
       for each function  in  the  load	 modules  being	 profiled,  sorted  by
       decreasing  time.   On  Itanium-based systems, the module index is also
       reported for each function signifying the  load	module	in  which  the
       function is defined.

       Next,  these  times  are	 propagated along the edges of the call graph.
       discovers all cycles in the call graph.	All calls made into the	 cycle
       share  the  time	 of  that cycle.  A second listing shows the functions
       sorted according to the time they represent including the time of their
       call  graph  descendants.   Below  each	function  entry	 is  shown its
       (direct) call graph children, and how their  times  are	propagated  to
       this function.  A similar display above the function shows how the time
       of this function and the time of its descendants are propagated to  its
       (direct) call graph parents.

       Cycles  are  also  shown,  with an entry for the cycle as a whole and a
       listing of the members of the cycle, each with their  contributions  to
       the time and call counts of the cycle.

       On Itanium-based systems, in the end a mapping of all module indices to
       module names is given.  The modules not being profiled are reported  at
       the top of output.

   Shared Library Profiling
       Support	for  profiling of shared libraries is available both on 32-bit
       and 64-bit Itanium-based	 systems.   On	PA-RISC	 systems  only	32-bit
       shared library profiling is supported.

	      The  environment	variable determines what load modules get pro‐
	      filed.  Set to profile all load modules; that is, report	timing
	      and  call	 count information for all loadable modules, including
	      Set to profile only loadable modules ldm1 and  ldm2.   ldm1  and
	      ldm2  are not full pathnames; they are the names recorded in the
	      executables, which can be displayed using chatr(1).  If  is  not
	      set, behaves as though

	      The  environment	variable  controls the size of profiling coun‐
	      ters.  The acceptable value for  this  variable  is  16  or  32.
	      Counter  size  can  also	be specified at compile time using the
	      option.  The runtime value overrides the compile time value.   A
	      warning  is  issued  if the counter size is set to a value other
	      than 16 or 32; in this case the value specified at compile  time
	      is  used.	 The default value of the counter is 16, which is used
	      if a valid value is not specified.  See the description  of  the
	      option in cc(1) for more details.

	      At  program termination the library dumps all profiling informa‐
	      tion on a per-module  basis  in  which  the  command  reads  and
	      matches to corresponding functions in the load modules.

	      To profile a shared library, set the environment variable to the
	      path of the shared library to be profiled.  (See	for  details.)
	      Do  not  use  the	 option to compile programs for shared library
	      profiling.  Do not link the executable or This turns on  profil‐
	      ing  of  which  is  not  compatible  with	 profiling  of	shared
	      libraries.  You can either profile your executable or  a	shared
	      library, but not both.

	      Set  to  the  exact string with which you call If the library is
	      implicitly loaded, must match the path encoded in	 the  You  can
	      find this value by running the command on the executable.

	      At  the termination of the program, a profile file with the name
	      of the shared library prepended to it is generated by a run-time
	      library.	 To get the complete listing, provide the command with
	      names of the shared library and the profile file for the	shared
	      library as arguments.

       The command recognizes the following options:

	      Suppress printing statically declared functions.
			     If this option is given, all relevant information
			     about the static function (such as time  samples,
			     calls  to	other  functions, and calls from other
			     functions) belongs to the	function  loaded  just
			     before the static function in the file.

	      Suppress printing a description of each field in the profile.

	      Suppress printing the graph profile entry for routine
			     name  and	all  its descendants (unless they have
			     other ancestors that are not  suppressed).	  More
			     than  one option can be given.  Only one name can
			     be given with each option.

	      Suppress printing the graph profile entry for routine
			     name (and its descendants)	 as  above,  and  also
			     exclude  the  time spent in name (and its descen‐
			     dants) from the total and percentage time	compu‐
			     tations.  is the default.

	      Print only the graph profile entry of the specified routine
			     name  and	its descendants.  More than one option
			     can be given.  Only one name can  be  given  with
			     each option.

	      Print only the graph profile entry of the routine
			     name  and its descendants (as above) and also use
			     only the times of the printed routines  in	 total
			     time  and percentage computations.	 More than one
			     option can be given.  Only one name can be	 given
			     with  each	 option.   The	option	overrides  the

	      Produce just the flat profile output
			     exactly similar to one given by (see prof(1)).

	      Produce a profile file
			     that represents the sum of the  profile  informa‐
			     tion  in  all specified profile files.  This sum‐
			     mary profile file can be given to subsequent exe‐
			     cutions of (probably also with a option) to accu‐
			     mulate profile data across	 several  runs	of  an
			     file.   should  be set to the same string for all
			     the runs.

	      Produce just the static output in
			     This is used for testing purposes.	 It eliminates
			     all the timing information from normal output and
			     reports only the call count part.

	      Display routines that have zero usage
			     (as indicated  by	call  counts  and  accumulated

       The  environment	 variable  controls  the name of the file created by a
       profiled program.  If is not set, is produced in the current  directory
       when  the  program  terminates.	If is produced, where progname is with
       any path prefix removed, and pid is the program's process  ID.	If  is
       set to a null string, no profiling output is produced.

   Environment Variables
       determines the modules to be profiled.

       controls the size of profiling counters.

       controls the path and name of the file created by a profiled program.

       To profile and on Itanium-based systems:

	      $ cat > test.c
	      void a()
		      printf("I in a\n");

	      $ cc -c +Z -G test.c
	      $ ld -b -o test.o
	      $ ln -s ./
	      $ cat > main.c
	      extern void a();
		      printf("Hello world\n");

	      $ cc -G main.c  -L. -ltest
	      $ export
	      $ export LD_PROFILEBUCKET_SIZE=16
	      $ ./a.out
	      hello world
	      I in a

	      $ unset LD_PROFILE
	      $ ls gmon.out

	      $ gprof

       To profile on PA-RISC systems:

	      $ cat > test.c
		      printf("hello world\n");

	      $ cc test.c -lc
	      $ ldd a.out
		      /usr/lib/libc.2 =>      /usr/lib/libc.2
		      /usr/lib/libdld.2 =>    /usr/lib/libdld.2
		      /usr/lib/libc.2 =>      /usr/lib/libc.2

	      $ export LD_PROFILE=/usr/lib/libc.2
	      $ ./a.out
	      hello world

	      $ unset LD_PROFILE
	      $ ls libc.2.profile

	      $ gprof /usr/lib/libc.2 libc.2.profile

       Beware  of  quantization	 errors.   The	granularity of the sampling is
       shown, but remains statistical at best.	It is assumed  that  the  time
       for each execution of a function can be expressed by the total time for
       the function, divided by the number of times the	 function  is  called.
       Thus  the  time propagated along the call graph arcs to parents of that
       function is directly proportional to the number of times	 that  arc  is

       Parents	that are not profiled have the time of their profiled children
       propagated to them, but they appear to be spontaneously invoked in  the
       call  graph  listing,  and  do  not have their time propagated further.
       Similarly, signal catchers, even though profiled, appear to be  sponta‐
       neous  (although	 for  more obscure reasons).  Any profiled children of
       signal catchers should have their times propagated properly unless  the
       signal  catcher	was invoked during the execution of the profiling rou‐
       tine, in which case all is lost.

       The following limitations exist for shared library profiling on PA-RISC

       ·      Local, static, and hidden functions are not profiled.

       ·      Shared libraries built with are not profiled.

       ·      Any  function  calls made from library initializers are not col‐

       cannot be used with dynamically linked executables (built with in  pre-
       HP-UX 10.20 releases).

       was developed by the University of California, Berkeley.

       Default object file.
       Default dynamic call graph and profile.
       Summarized dynamic call graph and profile.
       Call graph description.
       Flat profile description.
       32-bit shared library on Itanium-based systems.
       64-bit shared library on Itanium-based systems.
       32-bit shared library on PA-RISC systems.
       64-bit shared library on PA-RISC systems.

       aCC(1),	cc(1),	cc_bundled(1),	f90(1),	 ld(1), prof(1), exit(2), pro‐
       fil(2), sprofil(2), monitor(3C), smonitor(3C), crt0(3).

       Graham, S.L., Kessler, P.B., McKusick, M.K.

       SIGPLAN Notices; Vol. 17, No. 6, pp. 120-126, June 1982.

       (See the option).


List of man pages available for HP-UX

Copyright (c) for man pages and the logo by the respective OS vendor.

For those who want to learn more, the polarhome community provides shell access and support.

[legal] [privacy] [GNU] [policy] [cookies] [netiquette] [sponsors] [FAQ]
Polarhome, production since 1999.
Member of Polarhome portal.
Based on Fawad Halim's script.
Vote for polarhome
Free Shell Accounts :: the biggest list on the net