1This is gprof.info, produced by makeinfo version 5.1 from gprof.texi. 2 3This file documents the gprof profiler of the GNU system. 4 5 Copyright (C) 1988-2021 Free Software Foundation, Inc. 6 7 Permission is granted to copy, distribute and/or modify this document 8under the terms of the GNU Free Documentation License, Version 1.3 or 9any later version published by the Free Software Foundation; with no 10Invariant Sections, with no Front-Cover Texts, and with no Back-Cover 11Texts. A copy of the license is included in the section entitled "GNU 12Free Documentation License". 13 14INFO-DIR-SECTION Software development 15START-INFO-DIR-ENTRY 16* gprof: (gprof). Profiling your program's execution 17END-INFO-DIR-ENTRY 18 19 20File: gprof.info, Node: Top, Next: Introduction, Up: (dir) 21 22Profiling a Program: Where Does It Spend Its Time? 23************************************************** 24 25This manual describes the GNU profiler, 'gprof', and how you can use it 26to determine which parts of a program are taking most of the execution 27time. We assume that you know how to write, compile, and execute 28programs. GNU 'gprof' was written by Jay Fenlason. 29 30 This manual is for 'gprof' (GNU Toolchain for the A-profile 31Architecture 10.3-2021.07 (arm-10.29)) version 2.36.1. 32 33 This document is distributed under the terms of the GNU Free 34Documentation License version 1.3. A copy of the license is included in 35the section entitled "GNU Free Documentation License". 36 37* Menu: 38 39* Introduction:: What profiling means, and why it is useful. 40 41* Compiling:: How to compile your program for profiling. 42* Executing:: Executing your program to generate profile data 43* Invoking:: How to run 'gprof', and its options 44 45* Output:: Interpreting 'gprof''s output 46 47* Inaccuracy:: Potential problems you should be aware of 48* How do I?:: Answers to common questions 49* Incompatibilities:: (between GNU 'gprof' and Unix 'gprof'.) 50* Details:: Details of how profiling is done 51* GNU Free Documentation License:: GNU Free Documentation License 52 53 54File: gprof.info, Node: Introduction, Next: Compiling, Prev: Top, Up: Top 55 561 Introduction to Profiling 57*************************** 58 59Profiling allows you to learn where your program spent its time and 60which functions called which other functions while it was executing. 61This information can show you which pieces of your program are slower 62than you expected, and might be candidates for rewriting to make your 63program execute faster. It can also tell you which functions are being 64called more or less often than you expected. This may help you spot 65bugs that had otherwise been unnoticed. 66 67 Since the profiler uses information collected during the actual 68execution of your program, it can be used on programs that are too large 69or too complex to analyze by reading the source. However, how your 70program is run will affect the information that shows up in the profile 71data. If you don't use some feature of your program while it is being 72profiled, no profile information will be generated for that feature. 73 74 Profiling has several steps: 75 76 * You must compile and link your program with profiling enabled. 77 *Note Compiling a Program for Profiling: Compiling. 78 79 * You must execute your program to generate a profile data file. 80 *Note Executing the Program: Executing. 81 82 * You must run 'gprof' to analyze the profile data. *Note 'gprof' 83 Command Summary: Invoking. 84 85 The next three chapters explain these steps in greater detail. 86 87 Several forms of output are available from the analysis. 88 89 The "flat profile" shows how much time your program spent in each 90function, and how many times that function was called. If you simply 91want to know which functions burn most of the cycles, it is stated 92concisely here. *Note The Flat Profile: Flat Profile. 93 94 The "call graph" shows, for each function, which functions called it, 95which other functions it called, and how many times. There is also an 96estimate of how much time was spent in the subroutines of each function. 97This can suggest places where you might try to eliminate function calls 98that use a lot of time. *Note The Call Graph: Call Graph. 99 100 The "annotated source" listing is a copy of the program's source 101code, labeled with the number of times each line of the program was 102executed. *Note The Annotated Source Listing: Annotated Source. 103 104 To better understand how profiling works, you may wish to read a 105description of its implementation. *Note Implementation of Profiling: 106Implementation. 107 108 109File: gprof.info, Node: Compiling, Next: Executing, Prev: Introduction, Up: Top 110 1112 Compiling a Program for Profiling 112*********************************** 113 114The first step in generating profile information for your program is to 115compile and link it with profiling enabled. 116 117 To compile a source file for profiling, specify the '-pg' option when 118you run the compiler. (This is in addition to the options you normally 119use.) 120 121 To link the program for profiling, if you use a compiler such as 'cc' 122to do the linking, simply specify '-pg' in addition to your usual 123options. The same option, '-pg', alters either compilation or linking 124to do what is necessary for profiling. Here are examples: 125 126 cc -g -c myprog.c utils.c -pg 127 cc -o myprog myprog.o utils.o -pg 128 129 The '-pg' option also works with a command that both compiles and 130links: 131 132 cc -o myprog myprog.c utils.c -g -pg 133 134 Note: The '-pg' option must be part of your compilation options as 135well as your link options. If it is not then no call-graph data will be 136gathered and when you run 'gprof' you will get an error message like 137this: 138 139 gprof: gmon.out file is missing call-graph data 140 141 If you add the '-Q' switch to suppress the printing of the call graph 142data you will still be able to see the time samples: 143 144 Flat profile: 145 146 Each sample counts as 0.01 seconds. 147 % cumulative self self total 148 time seconds seconds calls Ts/call Ts/call name 149 44.12 0.07 0.07 zazLoop 150 35.29 0.14 0.06 main 151 20.59 0.17 0.04 bazMillion 152 153 If you run the linker 'ld' directly instead of through a compiler 154such as 'cc', you may have to specify a profiling startup file 'gcrt0.o' 155as the first input file instead of the usual startup file 'crt0.o'. In 156addition, you would probably want to specify the profiling C library, 157'libc_p.a', by writing '-lc_p' instead of the usual '-lc'. This is not 158absolutely necessary, but doing this gives you number-of-calls 159information for standard library functions such as 'read' and 'open'. 160For example: 161 162 ld -o myprog /lib/gcrt0.o myprog.o utils.o -lc_p 163 164 If you are running the program on a system which supports shared 165libraries you may run into problems with the profiling support code in a 166shared library being called before that library has been fully 167initialised. This is usually detected by the program encountering a 168segmentation fault as soon as it is run. The solution is to link 169against a static version of the library containing the profiling support 170code, which for 'gcc' users can be done via the '-static' or 171'-static-libgcc' command-line option. For example: 172 173 gcc -g -pg -static-libgcc myprog.c utils.c -o myprog 174 175 If you compile only some of the modules of the program with '-pg', 176you can still profile the program, but you won't get complete 177information about the modules that were compiled without '-pg'. The 178only information you get for the functions in those modules is the total 179time spent in them; there is no record of how many times they were 180called, or from where. This will not affect the flat profile (except 181that the 'calls' field for the functions will be blank), but will 182greatly reduce the usefulness of the call graph. 183 184 If you wish to perform line-by-line profiling you should use the 185'gcov' tool instead of 'gprof'. See that tool's manual or info pages 186for more details of how to do this. 187 188 Note, older versions of 'gcc' produce line-by-line profiling 189information that works with 'gprof' rather than 'gcov' so there is still 190support for displaying this kind of information in 'gprof'. *Note 191Line-by-line Profiling: Line-by-line. 192 193 It also worth noting that 'gcc' implements a '-finstrument-functions' 194command-line option which will insert calls to special user supplied 195instrumentation routines at the entry and exit of every function in 196their program. This can be used to implement an alternative profiling 197scheme. 198 199 200File: gprof.info, Node: Executing, Next: Invoking, Prev: Compiling, Up: Top 201 2023 Executing the Program 203*********************** 204 205Once the program is compiled for profiling, you must run it in order to 206generate the information that 'gprof' needs. Simply run the program as 207usual, using the normal arguments, file names, etc. The program should 208run normally, producing the same output as usual. It will, however, run 209somewhat slower than normal because of the time spent collecting and 210writing the profile data. 211 212 The way you run the program--the arguments and input that you give 213it--may have a dramatic effect on what the profile information shows. 214The profile data will describe the parts of the program that were 215activated for the particular input you use. For example, if the first 216command you give to your program is to quit, the profile data will show 217the time used in initialization and in cleanup, but not much else. 218 219 Your program will write the profile data into a file called 220'gmon.out' just before exiting. If there is already a file called 221'gmon.out', its contents are overwritten. There is currently no way to 222tell the program to write the profile data under a different name, but 223you can rename the file afterwards if you are concerned that it may be 224overwritten. 225 226 In order to write the 'gmon.out' file properly, your program must 227exit normally: by returning from 'main' or by calling 'exit'. Calling 228the low-level function '_exit' does not write the profile data, and 229neither does abnormal termination due to an unhandled signal. 230 231 The 'gmon.out' file is written in the program's _current working 232directory_ at the time it exits. This means that if your program calls 233'chdir', the 'gmon.out' file will be left in the last directory your 234program 'chdir''d to. If you don't have permission to write in this 235directory, the file is not written, and you will get an error message. 236 237 Older versions of the GNU profiling library may also write a file 238called 'bb.out'. This file, if present, contains an human-readable 239listing of the basic-block execution counts. Unfortunately, the 240appearance of a human-readable 'bb.out' means the basic-block counts 241didn't get written into 'gmon.out'. The Perl script 'bbconv.pl', 242included with the 'gprof' source distribution, will convert a 'bb.out' 243file into a format readable by 'gprof'. Invoke it like this: 244 245 bbconv.pl < bb.out > BH-DATA 246 247 This translates the information in 'bb.out' into a form that 'gprof' 248can understand. But you still need to tell 'gprof' about the existence 249of this translated information. To do that, include BB-DATA on the 250'gprof' command line, _along with 'gmon.out'_, like this: 251 252 gprof OPTIONS EXECUTABLE-FILE gmon.out BB-DATA [YET-MORE-PROFILE-DATA-FILES...] [> OUTFILE] 253 254 255File: gprof.info, Node: Invoking, Next: Output, Prev: Executing, Up: Top 256 2574 'gprof' Command Summary 258************************* 259 260After you have a profile data file 'gmon.out', you can run 'gprof' to 261interpret the information in it. The 'gprof' program prints a flat 262profile and a call graph on standard output. Typically you would 263redirect the output of 'gprof' into a file with '>'. 264 265 You run 'gprof' like this: 266 267 gprof OPTIONS [EXECUTABLE-FILE [PROFILE-DATA-FILES...]] [> OUTFILE] 268 269Here square-brackets indicate optional arguments. 270 271 If you omit the executable file name, the file 'a.out' is used. If 272you give no profile data file name, the file 'gmon.out' is used. If any 273file is not in the proper format, or if the profile data file does not 274appear to belong to the executable file, an error message is printed. 275 276 You can give more than one profile data file by entering all their 277names after the executable file name; then the statistics in all the 278data files are summed together. 279 280 The order of these options does not matter. 281 282* Menu: 283 284* Output Options:: Controlling 'gprof''s output style 285* Analysis Options:: Controlling how 'gprof' analyzes its data 286* Miscellaneous Options:: 287* Deprecated Options:: Options you no longer need to use, but which 288 have been retained for compatibility 289* Symspecs:: Specifying functions to include or exclude 290 291 292File: gprof.info, Node: Output Options, Next: Analysis Options, Up: Invoking 293 2944.1 Output Options 295================== 296 297These options specify which of several output formats 'gprof' should 298produce. 299 300 Many of these options take an optional "symspec" to specify functions 301to be included or excluded. These options can be specified multiple 302times, with different symspecs, to include or exclude sets of symbols. 303*Note Symspecs: Symspecs. 304 305 Specifying any of these options overrides the default ('-p -q'), 306which prints a flat profile and call graph analysis for all functions. 307 308'-A[SYMSPEC]' 309'--annotated-source[=SYMSPEC]' 310 The '-A' option causes 'gprof' to print annotated source code. If 311 SYMSPEC is specified, print output only for matching symbols. 312 *Note The Annotated Source Listing: Annotated Source. 313 314'-b' 315'--brief' 316 If the '-b' option is given, 'gprof' doesn't print the verbose 317 blurbs that try to explain the meaning of all of the fields in the 318 tables. This is useful if you intend to print out the output, or 319 are tired of seeing the blurbs. 320 321'-C[SYMSPEC]' 322'--exec-counts[=SYMSPEC]' 323 The '-C' option causes 'gprof' to print a tally of functions and 324 the number of times each was called. If SYMSPEC is specified, 325 print tally only for matching symbols. 326 327 If the profile data file contains basic-block count records, 328 specifying the '-l' option, along with '-C', will cause basic-block 329 execution counts to be tallied and displayed. 330 331'-i' 332'--file-info' 333 The '-i' option causes 'gprof' to display summary information about 334 the profile data file(s) and then exit. The number of histogram, 335 call graph, and basic-block count records is displayed. 336 337'-I DIRS' 338'--directory-path=DIRS' 339 The '-I' option specifies a list of search directories in which to 340 find source files. Environment variable GPROF_PATH can also be 341 used to convey this information. Used mostly for annotated source 342 output. 343 344'-J[SYMSPEC]' 345'--no-annotated-source[=SYMSPEC]' 346 The '-J' option causes 'gprof' not to print annotated source code. 347 If SYMSPEC is specified, 'gprof' prints annotated source, but 348 excludes matching symbols. 349 350'-L' 351'--print-path' 352 Normally, source filenames are printed with the path component 353 suppressed. The '-L' option causes 'gprof' to print the full 354 pathname of source filenames, which is determined from symbolic 355 debugging information in the image file and is relative to the 356 directory in which the compiler was invoked. 357 358'-p[SYMSPEC]' 359'--flat-profile[=SYMSPEC]' 360 The '-p' option causes 'gprof' to print a flat profile. If SYMSPEC 361 is specified, print flat profile only for matching symbols. *Note 362 The Flat Profile: Flat Profile. 363 364'-P[SYMSPEC]' 365'--no-flat-profile[=SYMSPEC]' 366 The '-P' option causes 'gprof' to suppress printing a flat profile. 367 If SYMSPEC is specified, 'gprof' prints a flat profile, but 368 excludes matching symbols. 369 370'-q[SYMSPEC]' 371'--graph[=SYMSPEC]' 372 The '-q' option causes 'gprof' to print the call graph analysis. 373 If SYMSPEC is specified, print call graph only for matching symbols 374 and their children. *Note The Call Graph: Call Graph. 375 376'-Q[SYMSPEC]' 377'--no-graph[=SYMSPEC]' 378 The '-Q' option causes 'gprof' to suppress printing the call graph. 379 If SYMSPEC is specified, 'gprof' prints a call graph, but excludes 380 matching symbols. 381 382'-t' 383'--table-length=NUM' 384 The '-t' option causes the NUM most active source lines in each 385 source file to be listed when source annotation is enabled. The 386 default is 10. 387 388'-y' 389'--separate-files' 390 This option affects annotated source output only. Normally, 391 'gprof' prints annotated source files to standard-output. If this 392 option is specified, annotated source for a file named 393 'path/FILENAME' is generated in the file 'FILENAME-ann'. If the 394 underlying file system would truncate 'FILENAME-ann' so that it 395 overwrites the original 'FILENAME', 'gprof' generates annotated 396 source in the file 'FILENAME.ann' instead (if the original file 397 name has an extension, that extension is _replaced_ with '.ann'). 398 399'-Z[SYMSPEC]' 400'--no-exec-counts[=SYMSPEC]' 401 The '-Z' option causes 'gprof' not to print a tally of functions 402 and the number of times each was called. If SYMSPEC is specified, 403 print tally, but exclude matching symbols. 404 405'-r' 406'--function-ordering' 407 The '--function-ordering' option causes 'gprof' to print a 408 suggested function ordering for the program based on profiling 409 data. This option suggests an ordering which may improve paging, 410 tlb and cache behavior for the program on systems which support 411 arbitrary ordering of functions in an executable. 412 413 The exact details of how to force the linker to place functions in 414 a particular order is system dependent and out of the scope of this 415 manual. 416 417'-R MAP_FILE' 418'--file-ordering MAP_FILE' 419 The '--file-ordering' option causes 'gprof' to print a suggested .o 420 link line ordering for the program based on profiling data. This 421 option suggests an ordering which may improve paging, tlb and cache 422 behavior for the program on systems which do not support arbitrary 423 ordering of functions in an executable. 424 425 Use of the '-a' argument is highly recommended with this option. 426 427 The MAP_FILE argument is a pathname to a file which provides 428 function name to object file mappings. The format of the file is 429 similar to the output of the program 'nm'. 430 431 c-parse.o:00000000 T yyparse 432 c-parse.o:00000004 C yyerrflag 433 c-lang.o:00000000 T maybe_objc_method_name 434 c-lang.o:00000000 T print_lang_statistics 435 c-lang.o:00000000 T recognize_objc_keyword 436 c-decl.o:00000000 T print_lang_identifier 437 c-decl.o:00000000 T print_lang_type 438 ... 439 440 To create a MAP_FILE with GNU 'nm', type a command like 'nm 441 --extern-only --defined-only -v --print-file-name program-name'. 442 443'-T' 444'--traditional' 445 The '-T' option causes 'gprof' to print its output in "traditional" 446 BSD style. 447 448'-w WIDTH' 449'--width=WIDTH' 450 Sets width of output lines to WIDTH. Currently only used when 451 printing the function index at the bottom of the call graph. 452 453'-x' 454'--all-lines' 455 This option affects annotated source output only. By default, only 456 the lines at the beginning of a basic-block are annotated. If this 457 option is specified, every line in a basic-block is annotated by 458 repeating the annotation for the first line. This behavior is 459 similar to 'tcov''s '-a'. 460 461'--demangle[=STYLE]' 462'--no-demangle' 463 These options control whether C++ symbol names should be demangled 464 when printing output. The default is to demangle symbols. The 465 '--no-demangle' option may be used to turn off demangling. 466 Different compilers have different mangling styles. The optional 467 demangling style argument can be used to choose an appropriate 468 demangling style for your compiler. 469 470 471File: gprof.info, Node: Analysis Options, Next: Miscellaneous Options, Prev: Output Options, Up: Invoking 472 4734.2 Analysis Options 474==================== 475 476'-a' 477'--no-static' 478 The '-a' option causes 'gprof' to suppress the printing of 479 statically declared (private) functions. (These are functions 480 whose names are not listed as global, and which are not visible 481 outside the file/function/block where they were defined.) Time 482 spent in these functions, calls to/from them, etc., will all be 483 attributed to the function that was loaded directly before it in 484 the executable file. This option affects both the flat profile and 485 the call graph. 486 487'-c' 488'--static-call-graph' 489 The '-c' option causes the call graph of the program to be 490 augmented by a heuristic which examines the text space of the 491 object file and identifies function calls in the binary machine 492 code. Since normal call graph records are only generated when 493 functions are entered, this option identifies children that could 494 have been called, but never were. Calls to functions that were not 495 compiled with profiling enabled are also identified, but only if 496 symbol table entries are present for them. Calls to dynamic 497 library routines are typically _not_ found by this option. Parents 498 or children identified via this heuristic are indicated in the call 499 graph with call counts of '0'. 500 501'-D' 502'--ignore-non-functions' 503 The '-D' option causes 'gprof' to ignore symbols which are not 504 known to be functions. This option will give more accurate profile 505 data on systems where it is supported (Solaris and HPUX for 506 example). 507 508'-k FROM/TO' 509 The '-k' option allows you to delete from the call graph any arcs 510 from symbols matching symspec FROM to those matching symspec TO. 511 512'-l' 513'--line' 514 The '-l' option enables line-by-line profiling, which causes 515 histogram hits to be charged to individual source code lines, 516 instead of functions. This feature only works with programs 517 compiled by older versions of the 'gcc' compiler. Newer versions 518 of 'gcc' are designed to work with the 'gcov' tool instead. 519 520 If the program was compiled with basic-block counting enabled, this 521 option will also identify how many times each line of code was 522 executed. While line-by-line profiling can help isolate where in a 523 large function a program is spending its time, it also 524 significantly increases the running time of 'gprof', and magnifies 525 statistical inaccuracies. *Note Statistical Sampling Error: 526 Sampling Error. 527 528'--inline-file-names' 529 This option causes 'gprof' to print the source file after each 530 symbol in both the flat profile and the call graph. The full path 531 to the file is printed if used with the '-L' option. 532 533'-m NUM' 534'--min-count=NUM' 535 This option affects execution count output only. Symbols that are 536 executed less than NUM times are suppressed. 537 538'-nSYMSPEC' 539'--time=SYMSPEC' 540 The '-n' option causes 'gprof', in its call graph analysis, to only 541 propagate times for symbols matching SYMSPEC. 542 543'-NSYMSPEC' 544'--no-time=SYMSPEC' 545 The '-n' option causes 'gprof', in its call graph analysis, not to 546 propagate times for symbols matching SYMSPEC. 547 548'-SFILENAME' 549'--external-symbol-table=FILENAME' 550 The '-S' option causes 'gprof' to read an external symbol table 551 file, such as '/proc/kallsyms', rather than read the symbol table 552 from the given object file (the default is 'a.out'). This is 553 useful for profiling kernel modules. 554 555'-z' 556'--display-unused-functions' 557 If you give the '-z' option, 'gprof' will mention all functions in 558 the flat profile, even those that were never called, and that had 559 no time spent in them. This is useful in conjunction with the '-c' 560 option for discovering which routines were never called. 561 562 563File: gprof.info, Node: Miscellaneous Options, Next: Deprecated Options, Prev: Analysis Options, Up: Invoking 564 5654.3 Miscellaneous Options 566========================= 567 568'-d[NUM]' 569'--debug[=NUM]' 570 The '-d NUM' option specifies debugging options. If NUM is not 571 specified, enable all debugging. *Note Debugging 'gprof': 572 Debugging. 573 574'-h' 575'--help' 576 The '-h' option prints command line usage. 577 578'-ONAME' 579'--file-format=NAME' 580 Selects the format of the profile data files. Recognized formats 581 are 'auto' (the default), 'bsd', '4.4bsd', 'magic', and 'prof' (not 582 yet supported). 583 584'-s' 585'--sum' 586 The '-s' option causes 'gprof' to summarize the information in the 587 profile data files it read in, and write out a profile data file 588 called 'gmon.sum', which contains all the information from the 589 profile data files that 'gprof' read in. The file 'gmon.sum' may 590 be one of the specified input files; the effect of this is to merge 591 the data in the other input files into 'gmon.sum'. 592 593 Eventually you can run 'gprof' again without '-s' to analyze the 594 cumulative data in the file 'gmon.sum'. 595 596'-v' 597'--version' 598 The '-v' flag causes 'gprof' to print the current version number, 599 and then exit. 600 601 602File: gprof.info, Node: Deprecated Options, Next: Symspecs, Prev: Miscellaneous Options, Up: Invoking 603 6044.4 Deprecated Options 605====================== 606 607These options have been replaced with newer versions that use symspecs. 608 609'-e FUNCTION_NAME' 610 The '-e FUNCTION' option tells 'gprof' to not print information 611 about the function FUNCTION_NAME (and its children...) in the call 612 graph. The function will still be listed as a child of any 613 functions that call it, but its index number will be shown as '[not 614 printed]'. More than one '-e' option may be given; only one 615 FUNCTION_NAME may be indicated with each '-e' option. 616 617'-E FUNCTION_NAME' 618 The '-E FUNCTION' option works like the '-e' option, but time spent 619 in the function (and children who were not called from anywhere 620 else), will not be used to compute the percentages-of-time for the 621 call graph. More than one '-E' option may be given; only one 622 FUNCTION_NAME may be indicated with each '-E' option. 623 624'-f FUNCTION_NAME' 625 The '-f FUNCTION' option causes 'gprof' to limit the call graph to 626 the function FUNCTION_NAME and its children (and their 627 children...). More than one '-f' option may be given; only one 628 FUNCTION_NAME may be indicated with each '-f' option. 629 630'-F FUNCTION_NAME' 631 The '-F FUNCTION' option works like the '-f' option, but only time 632 spent in the function and its children (and their children...) will 633 be used to determine total-time and percentages-of-time for the 634 call graph. More than one '-F' option may be given; only one 635 FUNCTION_NAME may be indicated with each '-F' option. The '-F' 636 option overrides the '-E' option. 637 638 Note that only one function can be specified with each '-e', '-E', 639'-f' or '-F' option. To specify more than one function, use multiple 640options. For example, this command: 641 642 gprof -e boring -f foo -f bar myprogram > gprof.output 643 644lists in the call graph all functions that were reached from either 645'foo' or 'bar' and were not reachable from 'boring'. 646 647 648File: gprof.info, Node: Symspecs, Prev: Deprecated Options, Up: Invoking 649 6504.5 Symspecs 651============ 652 653Many of the output options allow functions to be included or excluded 654using "symspecs" (symbol specifications), which observe the following 655syntax: 656 657 filename_containing_a_dot 658 | funcname_not_containing_a_dot 659 | linenumber 660 | ( [ any_filename ] `:' ( any_funcname | linenumber ) ) 661 662 Here are some sample symspecs: 663 664'main.c' 665 Selects everything in file 'main.c'--the dot in the string tells 666 'gprof' to interpret the string as a filename, rather than as a 667 function name. To select a file whose name does not contain a dot, 668 a trailing colon should be specified. For example, 'odd:' is 669 interpreted as the file named 'odd'. 670 671'main' 672 Selects all functions named 'main'. 673 674 Note that there may be multiple instances of the same function name 675 because some of the definitions may be local (i.e., static). 676 Unless a function name is unique in a program, you must use the 677 colon notation explained below to specify a function from a 678 specific source file. 679 680 Sometimes, function names contain dots. In such cases, it is 681 necessary to add a leading colon to the name. For example, ':.mul' 682 selects function '.mul'. 683 684 In some object file formats, symbols have a leading underscore. 685 'gprof' will normally not print these underscores. When you name a 686 symbol in a symspec, you should type it exactly as 'gprof' prints 687 it in its output. For example, if the compiler produces a symbol 688 '_main' from your 'main' function, 'gprof' still prints it as 689 'main' in its output, so you should use 'main' in symspecs. 690 691'main.c:main' 692 Selects function 'main' in file 'main.c'. 693 694'main.c:134' 695 Selects line 134 in file 'main.c'. 696 697 698File: gprof.info, Node: Output, Next: Inaccuracy, Prev: Invoking, Up: Top 699 7005 Interpreting 'gprof''s Output 701******************************* 702 703'gprof' can produce several different output styles, the most important 704of which are described below. The simplest output styles (file 705information, execution count, and function and file ordering) are not 706described here, but are documented with the respective options that 707trigger them. *Note Output Options: Output Options. 708 709* Menu: 710 711* Flat Profile:: The flat profile shows how much time was spent 712 executing directly in each function. 713* Call Graph:: The call graph shows which functions called which 714 others, and how much time each function used 715 when its subroutine calls are included. 716* Line-by-line:: 'gprof' can analyze individual source code lines 717* Annotated Source:: The annotated source listing displays source code 718 labeled with execution counts 719 720 721File: gprof.info, Node: Flat Profile, Next: Call Graph, Up: Output 722 7235.1 The Flat Profile 724==================== 725 726The "flat profile" shows the total amount of time your program spent 727executing each function. Unless the '-z' option is given, functions 728with no apparent time spent in them, and no apparent calls to them, are 729not mentioned. Note that if a function was not compiled for profiling, 730and didn't run long enough to show up on the program counter histogram, 731it will be indistinguishable from a function that was never called. 732 733 This is part of a flat profile for a small program: 734 735 Flat profile: 736 737 Each sample counts as 0.01 seconds. 738 % cumulative self self total 739 time seconds seconds calls ms/call ms/call name 740 33.34 0.02 0.02 7208 0.00 0.00 open 741 16.67 0.03 0.01 244 0.04 0.12 offtime 742 16.67 0.04 0.01 8 1.25 1.25 memccpy 743 16.67 0.05 0.01 7 1.43 1.43 write 744 16.67 0.06 0.01 mcount 745 0.00 0.06 0.00 236 0.00 0.00 tzset 746 0.00 0.06 0.00 192 0.00 0.00 tolower 747 0.00 0.06 0.00 47 0.00 0.00 strlen 748 0.00 0.06 0.00 45 0.00 0.00 strchr 749 0.00 0.06 0.00 1 0.00 50.00 main 750 0.00 0.06 0.00 1 0.00 0.00 memcpy 751 0.00 0.06 0.00 1 0.00 10.11 print 752 0.00 0.06 0.00 1 0.00 0.00 profil 753 0.00 0.06 0.00 1 0.00 50.00 report 754 ... 755 756The functions are sorted first by decreasing run-time spent in them, 757then by decreasing number of calls, then alphabetically by name. The 758functions 'mcount' and 'profil' are part of the profiling apparatus and 759appear in every flat profile; their time gives a measure of the amount 760of overhead due to profiling. 761 762 Just before the column headers, a statement appears indicating how 763much time each sample counted as. This "sampling period" estimates the 764margin of error in each of the time figures. A time figure that is not 765much larger than this is not reliable. In this example, each sample 766counted as 0.01 seconds, suggesting a 100 Hz sampling rate. The 767program's total execution time was 0.06 seconds, as indicated by the 768'cumulative seconds' field. Since each sample counted for 0.01 seconds, 769this means only six samples were taken during the run. Two of the 770samples occurred while the program was in the 'open' function, as 771indicated by the 'self seconds' field. Each of the other four samples 772occurred one each in 'offtime', 'memccpy', 'write', and 'mcount'. Since 773only six samples were taken, none of these values can be regarded as 774particularly reliable. In another run, the 'self seconds' field for 775'mcount' might well be '0.00' or '0.02'. *Note Statistical Sampling 776Error: Sampling Error, for a complete discussion. 777 778 The remaining functions in the listing (those whose 'self seconds' 779field is '0.00') didn't appear in the histogram samples at all. 780However, the call graph indicated that they were called, so therefore 781they are listed, sorted in decreasing order by the 'calls' field. 782Clearly some time was spent executing these functions, but the paucity 783of histogram samples prevents any determination of how much time each 784took. 785 786 Here is what the fields in each line mean: 787 788'% time' 789 This is the percentage of the total execution time your program 790 spent in this function. These should all add up to 100%. 791 792'cumulative seconds' 793 This is the cumulative total number of seconds the computer spent 794 executing this functions, plus the time spent in all the functions 795 above this one in this table. 796 797'self seconds' 798 This is the number of seconds accounted for by this function alone. 799 The flat profile listing is sorted first by this number. 800 801'calls' 802 This is the total number of times the function was called. If the 803 function was never called, or the number of times it was called 804 cannot be determined (probably because the function was not 805 compiled with profiling enabled), the "calls" field is blank. 806 807'self ms/call' 808 This represents the average number of milliseconds spent in this 809 function per call, if this function is profiled. Otherwise, this 810 field is blank for this function. 811 812'total ms/call' 813 This represents the average number of milliseconds spent in this 814 function and its descendants per call, if this function is 815 profiled. Otherwise, this field is blank for this function. This 816 is the only field in the flat profile that uses call graph 817 analysis. 818 819'name' 820 This is the name of the function. The flat profile is sorted by 821 this field alphabetically after the "self seconds" and "calls" 822 fields are sorted. 823 824 825File: gprof.info, Node: Call Graph, Next: Line-by-line, Prev: Flat Profile, Up: Output 826 8275.2 The Call Graph 828================== 829 830The "call graph" shows how much time was spent in each function and its 831children. From this information, you can find functions that, while 832they themselves may not have used much time, called other functions that 833did use unusual amounts of time. 834 835 Here is a sample call from a small program. This call came from the 836same 'gprof' run as the flat profile example in the previous section. 837 838 granularity: each sample hit covers 2 byte(s) for 20.00% of 0.05 seconds 839 840 index % time self children called name 841 <spontaneous> 842 [1] 100.0 0.00 0.05 start [1] 843 0.00 0.05 1/1 main [2] 844 0.00 0.00 1/2 on_exit [28] 845 0.00 0.00 1/1 exit [59] 846 ----------------------------------------------- 847 0.00 0.05 1/1 start [1] 848 [2] 100.0 0.00 0.05 1 main [2] 849 0.00 0.05 1/1 report [3] 850 ----------------------------------------------- 851 0.00 0.05 1/1 main [2] 852 [3] 100.0 0.00 0.05 1 report [3] 853 0.00 0.03 8/8 timelocal [6] 854 0.00 0.01 1/1 print [9] 855 0.00 0.01 9/9 fgets [12] 856 0.00 0.00 12/34 strncmp <cycle 1> [40] 857 0.00 0.00 8/8 lookup [20] 858 0.00 0.00 1/1 fopen [21] 859 0.00 0.00 8/8 chewtime [24] 860 0.00 0.00 8/16 skipspace [44] 861 ----------------------------------------------- 862 [4] 59.8 0.01 0.02 8+472 <cycle 2 as a whole> [4] 863 0.01 0.02 244+260 offtime <cycle 2> [7] 864 0.00 0.00 236+1 tzset <cycle 2> [26] 865 ----------------------------------------------- 866 867 The lines full of dashes divide this table into "entries", one for 868each function. Each entry has one or more lines. 869 870 In each entry, the primary line is the one that starts with an index 871number in square brackets. The end of this line says which function the 872entry is for. The preceding lines in the entry describe the callers of 873this function and the following lines describe its subroutines (also 874called "children" when we speak of the call graph). 875 876 The entries are sorted by time spent in the function and its 877subroutines. 878 879 The internal profiling function 'mcount' (*note The Flat Profile: 880Flat Profile.) is never mentioned in the call graph. 881 882* Menu: 883 884* Primary:: Details of the primary line's contents. 885* Callers:: Details of caller-lines' contents. 886* Subroutines:: Details of subroutine-lines' contents. 887* Cycles:: When there are cycles of recursion, 888 such as 'a' calls 'b' calls 'a'... 889 890 891File: gprof.info, Node: Primary, Next: Callers, Up: Call Graph 892 8935.2.1 The Primary Line 894---------------------- 895 896The "primary line" in a call graph entry is the line that describes the 897function which the entry is about and gives the overall statistics for 898this function. 899 900 For reference, we repeat the primary line from the entry for function 901'report' in our main example, together with the heading line that shows 902the names of the fields: 903 904 index % time self children called name 905 ... 906 [3] 100.0 0.00 0.05 1 report [3] 907 908 Here is what the fields in the primary line mean: 909 910'index' 911 Entries are numbered with consecutive integers. Each function 912 therefore has an index number, which appears at the beginning of 913 its primary line. 914 915 Each cross-reference to a function, as a caller or subroutine of 916 another, gives its index number as well as its name. The index 917 number guides you if you wish to look for the entry for that 918 function. 919 920'% time' 921 This is the percentage of the total time that was spent in this 922 function, including time spent in subroutines called from this 923 function. 924 925 The time spent in this function is counted again for the callers of 926 this function. Therefore, adding up these percentages is 927 meaningless. 928 929'self' 930 This is the total amount of time spent in this function. This 931 should be identical to the number printed in the 'seconds' field 932 for this function in the flat profile. 933 934'children' 935 This is the total amount of time spent in the subroutine calls made 936 by this function. This should be equal to the sum of all the 937 'self' and 'children' entries of the children listed directly below 938 this function. 939 940'called' 941 This is the number of times the function was called. 942 943 If the function called itself recursively, there are two numbers, 944 separated by a '+'. The first number counts non-recursive calls, 945 and the second counts recursive calls. 946 947 In the example above, the function 'report' was called once from 948 'main'. 949 950'name' 951 This is the name of the current function. The index number is 952 repeated after it. 953 954 If the function is part of a cycle of recursion, the cycle number 955 is printed between the function's name and the index number (*note 956 How Mutually Recursive Functions Are Described: Cycles.). For 957 example, if function 'gnurr' is part of cycle number one, and has 958 index number twelve, its primary line would be end like this: 959 960 gnurr <cycle 1> [12] 961 962 963File: gprof.info, Node: Callers, Next: Subroutines, Prev: Primary, Up: Call Graph 964 9655.2.2 Lines for a Function's Callers 966------------------------------------ 967 968A function's entry has a line for each function it was called by. These 969lines' fields correspond to the fields of the primary line, but their 970meanings are different because of the difference in context. 971 972 For reference, we repeat two lines from the entry for the function 973'report', the primary line and one caller-line preceding it, together 974with the heading line that shows the names of the fields: 975 976 index % time self children called name 977 ... 978 0.00 0.05 1/1 main [2] 979 [3] 100.0 0.00 0.05 1 report [3] 980 981 Here are the meanings of the fields in the caller-line for 'report' 982called from 'main': 983 984'self' 985 An estimate of the amount of time spent in 'report' itself when it 986 was called from 'main'. 987 988'children' 989 An estimate of the amount of time spent in subroutines of 'report' 990 when 'report' was called from 'main'. 991 992 The sum of the 'self' and 'children' fields is an estimate of the 993 amount of time spent within calls to 'report' from 'main'. 994 995'called' 996 Two numbers: the number of times 'report' was called from 'main', 997 followed by the total number of non-recursive calls to 'report' 998 from all its callers. 999 1000'name and index number' 1001 The name of the caller of 'report' to which this line applies, 1002 followed by the caller's index number. 1003 1004 Not all functions have entries in the call graph; some options to 1005 'gprof' request the omission of certain functions. When a caller 1006 has no entry of its own, it still has caller-lines in the entries 1007 of the functions it calls. 1008 1009 If the caller is part of a recursion cycle, the cycle number is 1010 printed between the name and the index number. 1011 1012 If the identity of the callers of a function cannot be determined, a 1013dummy caller-line is printed which has '<spontaneous>' as the "caller's 1014name" and all other fields blank. This can happen for signal handlers. 1015 1016 1017File: gprof.info, Node: Subroutines, Next: Cycles, Prev: Callers, Up: Call Graph 1018 10195.2.3 Lines for a Function's Subroutines 1020---------------------------------------- 1021 1022A function's entry has a line for each of its subroutines--in other 1023words, a line for each other function that it called. These lines' 1024fields correspond to the fields of the primary line, but their meanings 1025are different because of the difference in context. 1026 1027 For reference, we repeat two lines from the entry for the function 1028'main', the primary line and a line for a subroutine, together with the 1029heading line that shows the names of the fields: 1030 1031 index % time self children called name 1032 ... 1033 [2] 100.0 0.00 0.05 1 main [2] 1034 0.00 0.05 1/1 report [3] 1035 1036 Here are the meanings of the fields in the subroutine-line for 'main' 1037calling 'report': 1038 1039'self' 1040 An estimate of the amount of time spent directly within 'report' 1041 when 'report' was called from 'main'. 1042 1043'children' 1044 An estimate of the amount of time spent in subroutines of 'report' 1045 when 'report' was called from 'main'. 1046 1047 The sum of the 'self' and 'children' fields is an estimate of the 1048 total time spent in calls to 'report' from 'main'. 1049 1050'called' 1051 Two numbers, the number of calls to 'report' from 'main' followed 1052 by the total number of non-recursive calls to 'report'. This ratio 1053 is used to determine how much of 'report''s 'self' and 'children' 1054 time gets credited to 'main'. *Note Estimating 'children' Times: 1055 Assumptions. 1056 1057'name' 1058 The name of the subroutine of 'main' to which this line applies, 1059 followed by the subroutine's index number. 1060 1061 If the caller is part of a recursion cycle, the cycle number is 1062 printed between the name and the index number. 1063 1064 1065File: gprof.info, Node: Cycles, Prev: Subroutines, Up: Call Graph 1066 10675.2.4 How Mutually Recursive Functions Are Described 1068---------------------------------------------------- 1069 1070The graph may be complicated by the presence of "cycles of recursion" in 1071the call graph. A cycle exists if a function calls another function 1072that (directly or indirectly) calls (or appears to call) the original 1073function. For example: if 'a' calls 'b', and 'b' calls 'a', then 'a' 1074and 'b' form a cycle. 1075 1076 Whenever there are call paths both ways between a pair of functions, 1077they belong to the same cycle. If 'a' and 'b' call each other and 'b' 1078and 'c' call each other, all three make one cycle. Note that even if 1079'b' only calls 'a' if it was not called from 'a', 'gprof' cannot 1080determine this, so 'a' and 'b' are still considered a cycle. 1081 1082 The cycles are numbered with consecutive integers. When a function 1083belongs to a cycle, each time the function name appears in the call 1084graph it is followed by '<cycle NUMBER>'. 1085 1086 The reason cycles matter is that they make the time values in the 1087call graph paradoxical. The "time spent in children" of 'a' should 1088include the time spent in its subroutine 'b' and in 'b''s 1089subroutines--but one of 'b''s subroutines is 'a'! How much of 'a''s 1090time should be included in the children of 'a', when 'a' is indirectly 1091recursive? 1092 1093 The way 'gprof' resolves this paradox is by creating a single entry 1094for the cycle as a whole. The primary line of this entry describes the 1095total time spent directly in the functions of the cycle. The 1096"subroutines" of the cycle are the individual functions of the cycle, 1097and all other functions that were called directly by them. The 1098"callers" of the cycle are the functions, outside the cycle, that called 1099functions in the cycle. 1100 1101 Here is an example portion of a call graph which shows a cycle 1102containing functions 'a' and 'b'. The cycle was entered by a call to 1103'a' from 'main'; both 'a' and 'b' called 'c'. 1104 1105 index % time self children called name 1106 ---------------------------------------- 1107 1.77 0 1/1 main [2] 1108 [3] 91.71 1.77 0 1+5 <cycle 1 as a whole> [3] 1109 1.02 0 3 b <cycle 1> [4] 1110 0.75 0 2 a <cycle 1> [5] 1111 ---------------------------------------- 1112 3 a <cycle 1> [5] 1113 [4] 52.85 1.02 0 0 b <cycle 1> [4] 1114 2 a <cycle 1> [5] 1115 0 0 3/6 c [6] 1116 ---------------------------------------- 1117 1.77 0 1/1 main [2] 1118 2 b <cycle 1> [4] 1119 [5] 38.86 0.75 0 1 a <cycle 1> [5] 1120 3 b <cycle 1> [4] 1121 0 0 3/6 c [6] 1122 ---------------------------------------- 1123 1124(The entire call graph for this program contains in addition an entry 1125for 'main', which calls 'a', and an entry for 'c', with callers 'a' and 1126'b'.) 1127 1128 index % time self children called name 1129 <spontaneous> 1130 [1] 100.00 0 1.93 0 start [1] 1131 0.16 1.77 1/1 main [2] 1132 ---------------------------------------- 1133 0.16 1.77 1/1 start [1] 1134 [2] 100.00 0.16 1.77 1 main [2] 1135 1.77 0 1/1 a <cycle 1> [5] 1136 ---------------------------------------- 1137 1.77 0 1/1 main [2] 1138 [3] 91.71 1.77 0 1+5 <cycle 1 as a whole> [3] 1139 1.02 0 3 b <cycle 1> [4] 1140 0.75 0 2 a <cycle 1> [5] 1141 0 0 6/6 c [6] 1142 ---------------------------------------- 1143 3 a <cycle 1> [5] 1144 [4] 52.85 1.02 0 0 b <cycle 1> [4] 1145 2 a <cycle 1> [5] 1146 0 0 3/6 c [6] 1147 ---------------------------------------- 1148 1.77 0 1/1 main [2] 1149 2 b <cycle 1> [4] 1150 [5] 38.86 0.75 0 1 a <cycle 1> [5] 1151 3 b <cycle 1> [4] 1152 0 0 3/6 c [6] 1153 ---------------------------------------- 1154 0 0 3/6 b <cycle 1> [4] 1155 0 0 3/6 a <cycle 1> [5] 1156 [6] 0.00 0 0 6 c [6] 1157 ---------------------------------------- 1158 1159 The 'self' field of the cycle's primary line is the total time spent 1160in all the functions of the cycle. It equals the sum of the 'self' 1161fields for the individual functions in the cycle, found in the entry in 1162the subroutine lines for these functions. 1163 1164 The 'children' fields of the cycle's primary line and subroutine 1165lines count only subroutines outside the cycle. Even though 'a' calls 1166'b', the time spent in those calls to 'b' is not counted in 'a''s 1167'children' time. Thus, we do not encounter the problem of what to do 1168when the time in those calls to 'b' includes indirect recursive calls 1169back to 'a'. 1170 1171 The 'children' field of a caller-line in the cycle's entry estimates 1172the amount of time spent _in the whole cycle_, and its other 1173subroutines, on the times when that caller called a function in the 1174cycle. 1175 1176 The 'called' field in the primary line for the cycle has two numbers: 1177first, the number of times functions in the cycle were called by 1178functions outside the cycle; second, the number of times they were 1179called by functions in the cycle (including times when a function in the 1180cycle calls itself). This is a generalization of the usual split into 1181non-recursive and recursive calls. 1182 1183 The 'called' field of a subroutine-line for a cycle member in the 1184cycle's entry says how many time that function was called from functions 1185in the cycle. The total of all these is the second number in the 1186primary line's 'called' field. 1187 1188 In the individual entry for a function in a cycle, the other 1189functions in the same cycle can appear as subroutines and as callers. 1190These lines show how many times each function in the cycle called or was 1191called from each other function in the cycle. The 'self' and 'children' 1192fields in these lines are blank because of the difficulty of defining 1193meanings for them when recursion is going on. 1194 1195 1196File: gprof.info, Node: Line-by-line, Next: Annotated Source, Prev: Call Graph, Up: Output 1197 11985.3 Line-by-line Profiling 1199========================== 1200 1201'gprof''s '-l' option causes the program to perform "line-by-line" 1202profiling. In this mode, histogram samples are assigned not to 1203functions, but to individual lines of source code. This only works with 1204programs compiled with older versions of the 'gcc' compiler. Newer 1205versions of 'gcc' use a different program - 'gcov' - to display 1206line-by-line profiling information. 1207 1208 With the older versions of 'gcc' the program usually has to be 1209compiled with a '-g' option, in addition to '-pg', in order to generate 1210debugging symbols for tracking source code lines. Note, in much older 1211versions of 'gcc' the program had to be compiled with the '-a' 1212command-line option as well. 1213 1214 The flat profile is the most useful output table in line-by-line 1215mode. The call graph isn't as useful as normal, since the current 1216version of 'gprof' does not propagate call graph arcs from source code 1217lines to the enclosing function. The call graph does, however, show 1218each line of code that called each function, along with a count. 1219 1220 Here is a section of 'gprof''s output, without line-by-line 1221profiling. Note that 'ct_init' accounted for four histogram hits, and 122213327 calls to 'init_block'. 1223 1224 Flat profile: 1225 1226 Each sample counts as 0.01 seconds. 1227 % cumulative self self total 1228 time seconds seconds calls us/call us/call name 1229 30.77 0.13 0.04 6335 6.31 6.31 ct_init 1230 1231 1232 Call graph (explanation follows) 1233 1234 1235 granularity: each sample hit covers 4 byte(s) for 7.69% of 0.13 seconds 1236 1237 index % time self children called name 1238 1239 0.00 0.00 1/13496 name_too_long 1240 0.00 0.00 40/13496 deflate 1241 0.00 0.00 128/13496 deflate_fast 1242 0.00 0.00 13327/13496 ct_init 1243 [7] 0.0 0.00 0.00 13496 init_block 1244 1245 Now let's look at some of 'gprof''s output from the same program run, 1246this time with line-by-line profiling enabled. Note that 'ct_init''s 1247four histogram hits are broken down into four lines of source code--one 1248hit occurred on each of lines 349, 351, 382 and 385. In the call graph, 1249note how 'ct_init''s 13327 calls to 'init_block' are broken down into 1250one call from line 396, 3071 calls from line 384, 3730 calls from line 1251385, and 6525 calls from 387. 1252 1253 Flat profile: 1254 1255 Each sample counts as 0.01 seconds. 1256 % cumulative self 1257 time seconds seconds calls name 1258 7.69 0.10 0.01 ct_init (trees.c:349) 1259 7.69 0.11 0.01 ct_init (trees.c:351) 1260 7.69 0.12 0.01 ct_init (trees.c:382) 1261 7.69 0.13 0.01 ct_init (trees.c:385) 1262 1263 1264 Call graph (explanation follows) 1265 1266 1267 granularity: each sample hit covers 4 byte(s) for 7.69% of 0.13 seconds 1268 1269 % time self children called name 1270 1271 0.00 0.00 1/13496 name_too_long (gzip.c:1440) 1272 0.00 0.00 1/13496 deflate (deflate.c:763) 1273 0.00 0.00 1/13496 ct_init (trees.c:396) 1274 0.00 0.00 2/13496 deflate (deflate.c:727) 1275 0.00 0.00 4/13496 deflate (deflate.c:686) 1276 0.00 0.00 5/13496 deflate (deflate.c:675) 1277 0.00 0.00 12/13496 deflate (deflate.c:679) 1278 0.00 0.00 16/13496 deflate (deflate.c:730) 1279 0.00 0.00 128/13496 deflate_fast (deflate.c:654) 1280 0.00 0.00 3071/13496 ct_init (trees.c:384) 1281 0.00 0.00 3730/13496 ct_init (trees.c:385) 1282 0.00 0.00 6525/13496 ct_init (trees.c:387) 1283 [6] 0.0 0.00 0.00 13496 init_block (trees.c:408) 1284 1285 1286File: gprof.info, Node: Annotated Source, Prev: Line-by-line, Up: Output 1287 12885.4 The Annotated Source Listing 1289================================ 1290 1291'gprof''s '-A' option triggers an annotated source listing, which lists 1292the program's source code, each function labeled with the number of 1293times it was called. You may also need to specify the '-I' option, if 1294'gprof' can't find the source code files. 1295 1296 With older versions of 'gcc' compiling with 'gcc ... -g -pg -a' 1297augments your program with basic-block counting code, in addition to 1298function counting code. This enables 'gprof' to determine how many 1299times each line of code was executed. With newer versions of 'gcc' 1300support for displaying basic-block counts is provided by the 'gcov' 1301program. 1302 1303 For example, consider the following function, taken from gzip, with 1304line numbers added: 1305 1306 1 ulg updcrc(s, n) 1307 2 uch *s; 1308 3 unsigned n; 1309 4 { 1310 5 register ulg c; 1311 6 1312 7 static ulg crc = (ulg)0xffffffffL; 1313 8 1314 9 if (s == NULL) { 1315 10 c = 0xffffffffL; 1316 11 } else { 1317 12 c = crc; 1318 13 if (n) do { 1319 14 c = crc_32_tab[...]; 1320 15 } while (--n); 1321 16 } 1322 17 crc = c; 1323 18 return c ^ 0xffffffffL; 1324 19 } 1325 1326 'updcrc' has at least five basic-blocks. One is the function itself. 1327The 'if' statement on line 9 generates two more basic-blocks, one for 1328each branch of the 'if'. A fourth basic-block results from the 'if' on 1329line 13, and the contents of the 'do' loop form the fifth basic-block. 1330The compiler may also generate additional basic-blocks to handle various 1331special cases. 1332 1333 A program augmented for basic-block counting can be analyzed with 1334'gprof -l -A'. The '-x' option is also helpful, to ensure that each 1335line of code is labeled at least once. Here is 'updcrc''s annotated 1336source listing for a sample 'gzip' run: 1337 1338 ulg updcrc(s, n) 1339 uch *s; 1340 unsigned n; 1341 2 ->{ 1342 register ulg c; 1343 1344 static ulg crc = (ulg)0xffffffffL; 1345 1346 2 -> if (s == NULL) { 1347 1 -> c = 0xffffffffL; 1348 1 -> } else { 1349 1 -> c = crc; 1350 1 -> if (n) do { 1351 26312 -> c = crc_32_tab[...]; 1352 26312,1,26311 -> } while (--n); 1353 } 1354 2 -> crc = c; 1355 2 -> return c ^ 0xffffffffL; 1356 2 ->} 1357 1358 In this example, the function was called twice, passing once through 1359each branch of the 'if' statement. The body of the 'do' loop was 1360executed a total of 26312 times. Note how the 'while' statement is 1361annotated. It began execution 26312 times, once for each iteration 1362through the loop. One of those times (the last time) it exited, while 1363it branched back to the beginning of the loop 26311 times. 1364 1365 1366File: gprof.info, Node: Inaccuracy, Next: How do I?, Prev: Output, Up: Top 1367 13686 Inaccuracy of 'gprof' Output 1369****************************** 1370 1371* Menu: 1372 1373* Sampling Error:: Statistical margins of error 1374* Assumptions:: Estimating children times 1375 1376 1377File: gprof.info, Node: Sampling Error, Next: Assumptions, Up: Inaccuracy 1378 13796.1 Statistical Sampling Error 1380============================== 1381 1382The run-time figures that 'gprof' gives you are based on a sampling 1383process, so they are subject to statistical inaccuracy. If a function 1384runs only a small amount of time, so that on the average the sampling 1385process ought to catch that function in the act only once, there is a 1386pretty good chance it will actually find that function zero times, or 1387twice. 1388 1389 By contrast, the number-of-calls and basic-block figures are derived 1390by counting, not sampling. They are completely accurate and will not 1391vary from run to run if your program is deterministic and single 1392threaded. In multi-threaded applications, or single threaded 1393applications that link with multi-threaded libraries, the counts are 1394only deterministic if the counting function is thread-safe. (Note: 1395beware that the mcount counting function in glibc is _not_ thread-safe). 1396*Note Implementation of Profiling: Implementation. 1397 1398 The "sampling period" that is printed at the beginning of the flat 1399profile says how often samples are taken. The rule of thumb is that a 1400run-time figure is accurate if it is considerably bigger than the 1401sampling period. 1402 1403 The actual amount of error can be predicted. For N samples, the 1404_expected_ error is the square-root of N. For example, if the sampling 1405period is 0.01 seconds and 'foo''s run-time is 1 second, N is 100 1406samples (1 second/0.01 seconds), sqrt(N) is 10 samples, so the expected 1407error in 'foo''s run-time is 0.1 seconds (10*0.01 seconds), or ten 1408percent of the observed value. Again, if the sampling period is 0.01 1409seconds and 'bar''s run-time is 100 seconds, N is 10000 samples, sqrt(N) 1410is 100 samples, so the expected error in 'bar''s run-time is 1 second, 1411or one percent of the observed value. It is likely to vary this much 1412_on the average_ from one profiling run to the next. (_Sometimes_ it 1413will vary more.) 1414 1415 This does not mean that a small run-time figure is devoid of 1416information. If the program's _total_ run-time is large, a small 1417run-time for one function does tell you that that function used an 1418insignificant fraction of the whole program's time. Usually this means 1419it is not worth optimizing. 1420 1421 One way to get more accuracy is to give your program more (but 1422similar) input data so it will take longer. Another way is to combine 1423the data from several runs, using the '-s' option of 'gprof'. Here is 1424how: 1425 1426 1. Run your program once. 1427 1428 2. Issue the command 'mv gmon.out gmon.sum'. 1429 1430 3. Run your program again, the same as before. 1431 1432 4. Merge the new data in 'gmon.out' into 'gmon.sum' with this command: 1433 1434 gprof -s EXECUTABLE-FILE gmon.out gmon.sum 1435 1436 5. Repeat the last two steps as often as you wish. 1437 1438 6. Analyze the cumulative data using this command: 1439 1440 gprof EXECUTABLE-FILE gmon.sum > OUTPUT-FILE 1441 1442 1443File: gprof.info, Node: Assumptions, Prev: Sampling Error, Up: Inaccuracy 1444 14456.2 Estimating 'children' Times 1446=============================== 1447 1448Some of the figures in the call graph are estimates--for example, the 1449'children' time values and all the time figures in caller and subroutine 1450lines. 1451 1452 There is no direct information about these measurements in the 1453profile data itself. Instead, 'gprof' estimates them by making an 1454assumption about your program that might or might not be true. 1455 1456 The assumption made is that the average time spent in each call to 1457any function 'foo' is not correlated with who called 'foo'. If 'foo' 1458used 5 seconds in all, and 2/5 of the calls to 'foo' came from 'a', then 1459'foo' contributes 2 seconds to 'a''s 'children' time, by assumption. 1460 1461 This assumption is usually true enough, but for some programs it is 1462far from true. Suppose that 'foo' returns very quickly when its 1463argument is zero; suppose that 'a' always passes zero as an argument, 1464while other callers of 'foo' pass other arguments. In this program, all 1465the time spent in 'foo' is in the calls from callers other than 'a'. 1466But 'gprof' has no way of knowing this; it will blindly and incorrectly 1467charge 2 seconds of time in 'foo' to the children of 'a'. 1468 1469 We hope some day to put more complete data into 'gmon.out', so that 1470this assumption is no longer needed, if we can figure out how. For the 1471novice, the estimated figures are usually more useful than misleading. 1472 1473 1474File: gprof.info, Node: How do I?, Next: Incompatibilities, Prev: Inaccuracy, Up: Top 1475 14767 Answers to Common Questions 1477***************************** 1478 1479How can I get more exact information about hot spots in my program? 1480 1481 Looking at the per-line call counts only tells part of the story. 1482 Because 'gprof' can only report call times and counts by function, 1483 the best way to get finer-grained information on where the program 1484 is spending its time is to re-factor large functions into sequences 1485 of calls to smaller ones. Beware however that this can introduce 1486 artificial hot spots since compiling with '-pg' adds a significant 1487 overhead to function calls. An alternative solution is to use a 1488 non-intrusive profiler, e.g. oprofile. 1489 1490How do I find which lines in my program were executed the most times? 1491 1492 Use the 'gcov' program. 1493 1494How do I find which lines in my program called a particular function? 1495 1496 Use 'gprof -l' and lookup the function in the call graph. The 1497 callers will be broken down by function and line number. 1498 1499How do I analyze a program that runs for less than a second? 1500 1501 Try using a shell script like this one: 1502 1503 for i in `seq 1 100`; do 1504 fastprog 1505 mv gmon.out gmon.out.$i 1506 done 1507 1508 gprof -s fastprog gmon.out.* 1509 1510 gprof fastprog gmon.sum 1511 1512 If your program is completely deterministic, all the call counts 1513 will be simple multiples of 100 (i.e., a function called once in 1514 each run will appear with a call count of 100). 1515 1516 1517File: gprof.info, Node: Incompatibilities, Next: Details, Prev: How do I?, Up: Top 1518 15198 Incompatibilities with Unix 'gprof' 1520************************************* 1521 1522GNU 'gprof' and Berkeley Unix 'gprof' use the same data file 'gmon.out', 1523and provide essentially the same information. But there are a few 1524differences. 1525 1526 * GNU 'gprof' uses a new, generalized file format with support for 1527 basic-block execution counts and non-realtime histograms. A magic 1528 cookie and version number allows 'gprof' to easily identify new 1529 style files. Old BSD-style files can still be read. *Note 1530 Profiling Data File Format: File Format. 1531 1532 * For a recursive function, Unix 'gprof' lists the function as a 1533 parent and as a child, with a 'calls' field that lists the number 1534 of recursive calls. GNU 'gprof' omits these lines and puts the 1535 number of recursive calls in the primary line. 1536 1537 * When a function is suppressed from the call graph with '-e', GNU 1538 'gprof' still lists it as a subroutine of functions that call it. 1539 1540 * GNU 'gprof' accepts the '-k' with its argument in the form 1541 'from/to', instead of 'from to'. 1542 1543 * In the annotated source listing, if there are multiple basic blocks 1544 on the same line, GNU 'gprof' prints all of their counts, separated 1545 by commas. 1546 1547 * The blurbs, field widths, and output formats are different. GNU 1548 'gprof' prints blurbs after the tables, so that you can see the 1549 tables without skipping the blurbs. 1550 1551 1552File: gprof.info, Node: Details, Next: GNU Free Documentation License, Prev: Incompatibilities, Up: Top 1553 15549 Details of Profiling 1555********************** 1556 1557* Menu: 1558 1559* Implementation:: How a program collects profiling information 1560* File Format:: Format of 'gmon.out' files 1561* Internals:: 'gprof''s internal operation 1562* Debugging:: Using 'gprof''s '-d' option 1563 1564 1565File: gprof.info, Node: Implementation, Next: File Format, Up: Details 1566 15679.1 Implementation of Profiling 1568=============================== 1569 1570Profiling works by changing how every function in your program is 1571compiled so that when it is called, it will stash away some information 1572about where it was called from. From this, the profiler can figure out 1573what function called it, and can count how many times it was called. 1574This change is made by the compiler when your program is compiled with 1575the '-pg' option, which causes every function to call 'mcount' (or 1576'_mcount', or '__mcount', depending on the OS and compiler) as one of 1577its first operations. 1578 1579 The 'mcount' routine, included in the profiling library, is 1580responsible for recording in an in-memory call graph table both its 1581parent routine (the child) and its parent's parent. This is typically 1582done by examining the stack frame to find both the address of the child, 1583and the return address in the original parent. Since this is a very 1584machine-dependent operation, 'mcount' itself is typically a short 1585assembly-language stub routine that extracts the required information, 1586and then calls '__mcount_internal' (a normal C function) with two 1587arguments--'frompc' and 'selfpc'. '__mcount_internal' is responsible 1588for maintaining the in-memory call graph, which records 'frompc', 1589'selfpc', and the number of times each of these call arcs was traversed. 1590 1591 GCC Version 2 provides a magical function 1592('__builtin_return_address'), which allows a generic 'mcount' function 1593to extract the required information from the stack frame. However, on 1594some architectures, most notably the SPARC, using this builtin can be 1595very computationally expensive, and an assembly language version of 1596'mcount' is used for performance reasons. 1597 1598 Number-of-calls information for library routines is collected by 1599using a special version of the C library. The programs in it are the 1600same as in the usual C library, but they were compiled with '-pg'. If 1601you link your program with 'gcc ... -pg', it automatically uses the 1602profiling version of the library. 1603 1604 Profiling also involves watching your program as it runs, and keeping 1605a histogram of where the program counter happens to be every now and 1606then. Typically the program counter is looked at around 100 times per 1607second of run time, but the exact frequency may vary from system to 1608system. 1609 1610 This is done is one of two ways. Most UNIX-like operating systems 1611provide a 'profil()' system call, which registers a memory array with 1612the kernel, along with a scale factor that determines how the program's 1613address space maps into the array. Typical scaling values cause every 2 1614to 8 bytes of address space to map into a single array slot. On every 1615tick of the system clock (assuming the profiled program is running), the 1616value of the program counter is examined and the corresponding slot in 1617the memory array is incremented. Since this is done in the kernel, 1618which had to interrupt the process anyway to handle the clock interrupt, 1619very little additional system overhead is required. 1620 1621 However, some operating systems, most notably Linux 2.0 (and 1622earlier), do not provide a 'profil()' system call. On such a system, 1623arrangements are made for the kernel to periodically deliver a signal to 1624the process (typically via 'setitimer()'), which then performs the same 1625operation of examining the program counter and incrementing a slot in 1626the memory array. Since this method requires a signal to be delivered 1627to user space every time a sample is taken, it uses considerably more 1628overhead than kernel-based profiling. Also, due to the added delay 1629required to deliver the signal, this method is less accurate as well. 1630 1631 A special startup routine allocates memory for the histogram and 1632either calls 'profil()' or sets up a clock signal handler. This routine 1633('monstartup') can be invoked in several ways. On Linux systems, a 1634special profiling startup file 'gcrt0.o', which invokes 'monstartup' 1635before 'main', is used instead of the default 'crt0.o'. Use of this 1636special startup file is one of the effects of using 'gcc ... -pg' to 1637link. On SPARC systems, no special startup files are used. Rather, the 1638'mcount' routine, when it is invoked for the first time (typically when 1639'main' is called), calls 'monstartup'. 1640 1641 If the compiler's '-a' option was used, basic-block counting is also 1642enabled. Each object file is then compiled with a static array of 1643counts, initially zero. In the executable code, every time a new 1644basic-block begins (i.e., when an 'if' statement appears), an extra 1645instruction is inserted to increment the corresponding count in the 1646array. At compile time, a paired array was constructed that recorded 1647the starting address of each basic-block. Taken together, the two 1648arrays record the starting address of every basic-block, along with the 1649number of times it was executed. 1650 1651 The profiling library also includes a function ('mcleanup') which is 1652typically registered using 'atexit()' to be called as the program exits, 1653and is responsible for writing the file 'gmon.out'. Profiling is turned 1654off, various headers are output, and the histogram is written, followed 1655by the call-graph arcs and the basic-block counts. 1656 1657 The output from 'gprof' gives no indication of parts of your program 1658that are limited by I/O or swapping bandwidth. This is because samples 1659of the program counter are taken at fixed intervals of the program's run 1660time. Therefore, the time measurements in 'gprof' output say nothing 1661about time that your program was not running. For example, a part of 1662the program that creates so much data that it cannot all fit in physical 1663memory at once may run very slowly due to thrashing, but 'gprof' will 1664say it uses little time. On the other hand, sampling by run time has 1665the advantage that the amount of load due to other users won't directly 1666affect the output you get. 1667 1668 1669File: gprof.info, Node: File Format, Next: Internals, Prev: Implementation, Up: Details 1670 16719.2 Profiling Data File Format 1672============================== 1673 1674The old BSD-derived file format used for profile data does not contain a 1675magic cookie that allows one to check whether a data file really is a 1676'gprof' file. Furthermore, it does not provide a version number, thus 1677rendering changes to the file format almost impossible. GNU 'gprof' 1678uses a new file format that provides these features. For backward 1679compatibility, GNU 'gprof' continues to support the old BSD-derived 1680format, but not all features are supported with it. For example, 1681basic-block execution counts cannot be accommodated by the old file 1682format. 1683 1684 The new file format is defined in header file 'gmon_out.h'. It 1685consists of a header containing the magic cookie and a version number, 1686as well as some spare bytes available for future extensions. All data 1687in a profile data file is in the native format of the target for which 1688the profile was collected. GNU 'gprof' adapts automatically to the 1689byte-order in use. 1690 1691 In the new file format, the header is followed by a sequence of 1692records. Currently, there are three different record types: histogram 1693records, call-graph arc records, and basic-block execution count 1694records. Each file can contain any number of each record type. When 1695reading a file, GNU 'gprof' will ensure records of the same type are 1696compatible with each other and compute the union of all records. For 1697example, for basic-block execution counts, the union is simply the sum 1698of all execution counts for each basic-block. 1699 17009.2.1 Histogram Records 1701----------------------- 1702 1703Histogram records consist of a header that is followed by an array of 1704bins. The header contains the text-segment range that the histogram 1705spans, the size of the histogram in bytes (unlike in the old BSD format, 1706this does not include the size of the header), the rate of the profiling 1707clock, and the physical dimension that the bin counts represent after 1708being scaled by the profiling clock rate. The physical dimension is 1709specified in two parts: a long name of up to 15 characters and a single 1710character abbreviation. For example, a histogram representing real-time 1711would specify the long name as "seconds" and the abbreviation as "s". 1712This feature is useful for architectures that support performance 1713monitor hardware (which, fortunately, is becoming increasingly common). 1714For example, under DEC OSF/1, the "uprofile" command can be used to 1715produce a histogram of, say, instruction cache misses. In this case, 1716the dimension in the histogram header could be set to "i-cache misses" 1717and the abbreviation could be set to "1" (because it is simply a count, 1718not a physical dimension). Also, the profiling rate would have to be 1719set to 1 in this case. 1720 1721 Histogram bins are 16-bit numbers and each bin represent an equal 1722amount of text-space. For example, if the text-segment is one thousand 1723bytes long and if there are ten bins in the histogram, each bin 1724represents one hundred bytes. 1725 17269.2.2 Call-Graph Records 1727------------------------ 1728 1729Call-graph records have a format that is identical to the one used in 1730the BSD-derived file format. It consists of an arc in the call graph 1731and a count indicating the number of times the arc was traversed during 1732program execution. Arcs are specified by a pair of addresses: the first 1733must be within caller's function and the second must be within the 1734callee's function. When performing profiling at the function level, 1735these addresses can point anywhere within the respective function. 1736However, when profiling at the line-level, it is better if the addresses 1737are as close to the call-site/entry-point as possible. This will ensure 1738that the line-level call-graph is able to identify exactly which line of 1739source code performed calls to a function. 1740 17419.2.3 Basic-Block Execution Count Records 1742----------------------------------------- 1743 1744Basic-block execution count records consist of a header followed by a 1745sequence of address/count pairs. The header simply specifies the length 1746of the sequence. In an address/count pair, the address identifies a 1747basic-block and the count specifies the number of times that basic-block 1748was executed. Any address within the basic-address can be used. 1749 1750 1751File: gprof.info, Node: Internals, Next: Debugging, Prev: File Format, Up: Details 1752 17539.3 'gprof''s Internal Operation 1754================================ 1755 1756Like most programs, 'gprof' begins by processing its options. During 1757this stage, it may building its symspec list ('sym_ids.c:sym_id_add'), 1758if options are specified which use symspecs. 'gprof' maintains a single 1759linked list of symspecs, which will eventually get turned into 12 symbol 1760tables, organized into six include/exclude pairs--one pair each for the 1761flat profile (INCL_FLAT/EXCL_FLAT), the call graph arcs 1762(INCL_ARCS/EXCL_ARCS), printing in the call graph 1763(INCL_GRAPH/EXCL_GRAPH), timing propagation in the call graph 1764(INCL_TIME/EXCL_TIME), the annotated source listing 1765(INCL_ANNO/EXCL_ANNO), and the execution count listing 1766(INCL_EXEC/EXCL_EXEC). 1767 1768 After option processing, 'gprof' finishes building the symspec list 1769by adding all the symspecs in 'default_excluded_list' to the exclude 1770lists EXCL_TIME and EXCL_GRAPH, and if line-by-line profiling is 1771specified, EXCL_FLAT as well. These default excludes are not added to 1772EXCL_ANNO, EXCL_ARCS, and EXCL_EXEC. 1773 1774 Next, the BFD library is called to open the object file, verify that 1775it is an object file, and read its symbol table ('core.c:core_init'), 1776using 'bfd_canonicalize_symtab' after mallocing an appropriately sized 1777array of symbols. At this point, function mappings are read (if the 1778'--file-ordering' option has been specified), and the core text space is 1779read into memory (if the '-c' option was given). 1780 1781 'gprof''s own symbol table, an array of Sym structures, is now built. 1782This is done in one of two ways, by one of two routines, depending on 1783whether line-by-line profiling ('-l' option) has been enabled. For 1784normal profiling, the BFD canonical symbol table is scanned. For 1785line-by-line profiling, every text space address is examined, and a new 1786symbol table entry gets created every time the line number changes. In 1787either case, two passes are made through the symbol table--one to count 1788the size of the symbol table required, and the other to actually read 1789the symbols. In between the two passes, a single array of type 'Sym' is 1790created of the appropriate length. Finally, 'symtab.c:symtab_finalize' 1791is called to sort the symbol table and remove duplicate entries (entries 1792with the same memory address). 1793 1794 The symbol table must be a contiguous array for two reasons. First, 1795the 'qsort' library function (which sorts an array) will be used to sort 1796the symbol table. Also, the symbol lookup routine 1797('symtab.c:sym_lookup'), which finds symbols based on memory address, 1798uses a binary search algorithm which requires the symbol table to be a 1799sorted array. Function symbols are indicated with an 'is_func' flag. 1800Line number symbols have no special flags set. Additionally, a symbol 1801can have an 'is_static' flag to indicate that it is a local symbol. 1802 1803 With the symbol table read, the symspecs can now be translated into 1804Syms ('sym_ids.c:sym_id_parse'). Remember that a single symspec can 1805match multiple symbols. An array of symbol tables ('syms') is created, 1806each entry of which is a symbol table of Syms to be included or excluded 1807from a particular listing. The master symbol table and the symspecs are 1808examined by nested loops, and every symbol that matches a symspec is 1809inserted into the appropriate syms table. This is done twice, once to 1810count the size of each required symbol table, and again to build the 1811tables, which have been malloced between passes. From now on, to 1812determine whether a symbol is on an include or exclude symspec list, 1813'gprof' simply uses its standard symbol lookup routine on the 1814appropriate table in the 'syms' array. 1815 1816 Now the profile data file(s) themselves are read 1817('gmon_io.c:gmon_out_read'), first by checking for a new-style 1818'gmon.out' header, then assuming this is an old-style BSD 'gmon.out' if 1819the magic number test failed. 1820 1821 New-style histogram records are read by 'hist.c:hist_read_rec'. For 1822the first histogram record, allocate a memory array to hold all the 1823bins, and read them in. When multiple profile data files (or files with 1824multiple histogram records) are read, the memory ranges of each pair of 1825histogram records must be either equal, or non-overlapping. For each 1826pair of histogram records, the resolution (memory region size divided by 1827the number of bins) must be the same. The time unit must be the same 1828for all histogram records. If the above containts are met, all 1829histograms for the same memory range are merged. 1830 1831 As each call graph record is read ('call_graph.c:cg_read_rec'), the 1832parent and child addresses are matched to symbol table entries, and a 1833call graph arc is created by 'cg_arcs.c:arc_add', unless the arc fails a 1834symspec check against INCL_ARCS/EXCL_ARCS. As each arc is added, a 1835linked list is maintained of the parent's child arcs, and of the child's 1836parent arcs. Both the child's call count and the arc's call count are 1837incremented by the record's call count. 1838 1839 Basic-block records are read ('basic_blocks.c:bb_read_rec'), but only 1840if line-by-line profiling has been selected. Each basic-block address 1841is matched to a corresponding line symbol in the symbol table, and an 1842entry made in the symbol's bb_addr and bb_calls arrays. Again, if 1843multiple basic-block records are present for the same address, the call 1844counts are cumulative. 1845 1846 A gmon.sum file is dumped, if requested ('gmon_io.c:gmon_out_write'). 1847 1848 If histograms were present in the data files, assign them to symbols 1849('hist.c:hist_assign_samples') by iterating over all the sample bins and 1850assigning them to symbols. Since the symbol table is sorted in order of 1851ascending memory addresses, we can simple follow along in the symbol 1852table as we make our pass over the sample bins. This step includes a 1853symspec check against INCL_FLAT/EXCL_FLAT. Depending on the histogram 1854scale factor, a sample bin may span multiple symbols, in which case a 1855fraction of the sample count is allocated to each symbol, proportional 1856to the degree of overlap. This effect is rare for normal profiling, but 1857overlaps are more common during line-by-line profiling, and can cause 1858each of two adjacent lines to be credited with half a hit, for example. 1859 1860 If call graph data is present, 'cg_arcs.c:cg_assemble' is called. 1861First, if '-c' was specified, a machine-dependent routine ('find_call') 1862scans through each symbol's machine code, looking for subroutine call 1863instructions, and adding them to the call graph with a zero call count. 1864A topological sort is performed by depth-first numbering all the symbols 1865('cg_dfn.c:cg_dfn'), so that children are always numbered less than 1866their parents, then making a array of pointers into the symbol table and 1867sorting it into numerical order, which is reverse topological order 1868(children appear before parents). Cycles are also detected at this 1869point, all members of which are assigned the same topological number. 1870Two passes are now made through this sorted array of symbol pointers. 1871The first pass, from end to beginning (parents to children), computes 1872the fraction of child time to propagate to each parent and a print flag. 1873The print flag reflects symspec handling of INCL_GRAPH/EXCL_GRAPH, with 1874a parent's include or exclude (print or no print) property being 1875propagated to its children, unless they themselves explicitly appear in 1876INCL_GRAPH or EXCL_GRAPH. A second pass, from beginning to end (children 1877to parents) actually propagates the timings along the call graph, 1878subject to a check against INCL_TIME/EXCL_TIME. With the print flag, 1879fractions, and timings now stored in the symbol structures, the 1880topological sort array is now discarded, and a new array of pointers is 1881assembled, this time sorted by propagated time. 1882 1883 Finally, print the various outputs the user requested, which is now 1884fairly straightforward. The call graph ('cg_print.c:cg_print') and flat 1885profile ('hist.c:hist_print') are regurgitations of values already 1886computed. The annotated source listing 1887('basic_blocks.c:print_annotated_source') uses basic-block information, 1888if present, to label each line of code with call counts, otherwise only 1889the function call counts are presented. 1890 1891 The function ordering code is marginally well documented in the 1892source code itself ('cg_print.c'). Basically, the functions with the 1893most use and the most parents are placed first, followed by other 1894functions with the most use, followed by lower use functions, followed 1895by unused functions at the end. 1896 1897 1898File: gprof.info, Node: Debugging, Prev: Internals, Up: Details 1899 19009.4 Debugging 'gprof' 1901===================== 1902 1903If 'gprof' was compiled with debugging enabled, the '-d' option triggers 1904debugging output (to stdout) which can be helpful in understanding its 1905operation. The debugging number specified is interpreted as a sum of 1906the following options: 1907 19082 - Topological sort 1909 Monitor depth-first numbering of symbols during call graph analysis 19104 - Cycles 1911 Shows symbols as they are identified as cycle heads 191216 - Tallying 1913 As the call graph arcs are read, show each arc and how the total 1914 calls to each function are tallied 191532 - Call graph arc sorting 1916 Details sorting individual parents/children within each call graph 1917 entry 191864 - Reading histogram and call graph records 1919 Shows address ranges of histograms as they are read, and each call 1920 graph arc 1921128 - Symbol table 1922 Reading, classifying, and sorting the symbol table from the object 1923 file. For line-by-line profiling ('-l' option), also shows line 1924 numbers being assigned to memory addresses. 1925256 - Static call graph 1926 Trace operation of '-c' option 1927512 - Symbol table and arc table lookups 1928 Detail operation of lookup routines 19291024 - Call graph propagation 1930 Shows how function times are propagated along the call graph 19312048 - Basic-blocks 1932 Shows basic-block records as they are read from profile data (only 1933 meaningful with '-l' option) 19344096 - Symspecs 1935 Shows symspec-to-symbol pattern matching operation 19368192 - Annotate source 1937 Tracks operation of '-A' option 1938 1939 1940File: gprof.info, Node: GNU Free Documentation License, Prev: Details, Up: Top 1941 1942Appendix A GNU Free Documentation License 1943***************************************** 1944 1945 Version 1.3, 3 November 2008 1946 1947 Copyright (C) 2000, 2001, 2002, 2007, 2008 Free Software Foundation, Inc. 1948 <http://fsf.org/> 1949 1950 Everyone is permitted to copy and distribute verbatim copies 1951 of this license document, but changing it is not allowed. 1952 1953 0. PREAMBLE 1954 1955 The purpose of this License is to make a manual, textbook, or other 1956 functional and useful document "free" in the sense of freedom: to 1957 assure everyone the effective freedom to copy and redistribute it, 1958 with or without modifying it, either commercially or 1959 noncommercially. Secondarily, this License preserves for the 1960 author and publisher a way to get credit for their work, while not 1961 being considered responsible for modifications made by others. 1962 1963 This License is a kind of "copyleft", which means that derivative 1964 works of the document must themselves be free in the same sense. 1965 It complements the GNU General Public License, which is a copyleft 1966 license designed for free software. 1967 1968 We have designed this License in order to use it for manuals for 1969 free software, because free software needs free documentation: a 1970 free program should come with manuals providing the same freedoms 1971 that the software does. But this License is not limited to 1972 software manuals; it can be used for any textual work, regardless 1973 of subject matter or whether it is published as a printed book. We 1974 recommend this License principally for works whose purpose is 1975 instruction or reference. 1976 1977 1. APPLICABILITY AND DEFINITIONS 1978 1979 This License applies to any manual or other work, in any medium, 1980 that contains a notice placed by the copyright holder saying it can 1981 be distributed under the terms of this License. Such a notice 1982 grants a world-wide, royalty-free license, unlimited in duration, 1983 to use that work under the conditions stated herein. The 1984 "Document", below, refers to any such manual or work. Any member 1985 of the public is a licensee, and is addressed as "you". You accept 1986 the license if you copy, modify or distribute the work in a way 1987 requiring permission under copyright law. 1988 1989 A "Modified Version" of the Document means any work containing the 1990 Document or a portion of it, either copied verbatim, or with 1991 modifications and/or translated into another language. 1992 1993 A "Secondary Section" is a named appendix or a front-matter section 1994 of the Document that deals exclusively with the relationship of the 1995 publishers or authors of the Document to the Document's overall 1996 subject (or to related matters) and contains nothing that could 1997 fall directly within that overall subject. (Thus, if the Document 1998 is in part a textbook of mathematics, a Secondary Section may not 1999 explain any mathematics.) The relationship could be a matter of 2000 historical connection with the subject or with related matters, or 2001 of legal, commercial, philosophical, ethical or political position 2002 regarding them. 2003 2004 The "Invariant Sections" are certain Secondary Sections whose 2005 titles are designated, as being those of Invariant Sections, in the 2006 notice that says that the Document is released under this License. 2007 If a section does not fit the above definition of Secondary then it 2008 is not allowed to be designated as Invariant. The Document may 2009 contain zero Invariant Sections. If the Document does not identify 2010 any Invariant Sections then there are none. 2011 2012 The "Cover Texts" are certain short passages of text that are 2013 listed, as Front-Cover Texts or Back-Cover Texts, in the notice 2014 that says that the Document is released under this License. A 2015 Front-Cover Text may be at most 5 words, and a Back-Cover Text may 2016 be at most 25 words. 2017 2018 A "Transparent" copy of the Document means a machine-readable copy, 2019 represented in a format whose specification is available to the 2020 general public, that is suitable for revising the document 2021 straightforwardly with generic text editors or (for images composed 2022 of pixels) generic paint programs or (for drawings) some widely 2023 available drawing editor, and that is suitable for input to text 2024 formatters or for automatic translation to a variety of formats 2025 suitable for input to text formatters. A copy made in an otherwise 2026 Transparent file format whose markup, or absence of markup, has 2027 been arranged to thwart or discourage subsequent modification by 2028 readers is not Transparent. An image format is not Transparent if 2029 used for any substantial amount of text. A copy that is not 2030 "Transparent" is called "Opaque". 2031 2032 Examples of suitable formats for Transparent copies include plain 2033 ASCII without markup, Texinfo input format, LaTeX input format, 2034 SGML or XML using a publicly available DTD, and standard-conforming 2035 simple HTML, PostScript or PDF designed for human modification. 2036 Examples of transparent image formats include PNG, XCF and JPG. 2037 Opaque formats include proprietary formats that can be read and 2038 edited only by proprietary word processors, SGML or XML for which 2039 the DTD and/or processing tools are not generally available, and 2040 the machine-generated HTML, PostScript or PDF produced by some word 2041 processors for output purposes only. 2042 2043 The "Title Page" means, for a printed book, the title page itself, 2044 plus such following pages as are needed to hold, legibly, the 2045 material this License requires to appear in the title page. For 2046 works in formats which do not have any title page as such, "Title 2047 Page" means the text near the most prominent appearance of the 2048 work's title, preceding the beginning of the body of the text. 2049 2050 The "publisher" means any person or entity that distributes copies 2051 of the Document to the public. 2052 2053 A section "Entitled XYZ" means a named subunit of the Document 2054 whose title either is precisely XYZ or contains XYZ in parentheses 2055 following text that translates XYZ in another language. (Here XYZ 2056 stands for a specific section name mentioned below, such as 2057 "Acknowledgements", "Dedications", "Endorsements", or "History".) 2058 To "Preserve the Title" of such a section when you modify the 2059 Document means that it remains a section "Entitled XYZ" according 2060 to this definition. 2061 2062 The Document may include Warranty Disclaimers next to the notice 2063 which states that this License applies to the Document. These 2064 Warranty Disclaimers are considered to be included by reference in 2065 this License, but only as regards disclaiming warranties: any other 2066 implication that these Warranty Disclaimers may have is void and 2067 has no effect on the meaning of this License. 2068 2069 2. VERBATIM COPYING 2070 2071 You may copy and distribute the Document in any medium, either 2072 commercially or noncommercially, provided that this License, the 2073 copyright notices, and the license notice saying this License 2074 applies to the Document are reproduced in all copies, and that you 2075 add no other conditions whatsoever to those of this License. You 2076 may not use technical measures to obstruct or control the reading 2077 or further copying of the copies you make or distribute. However, 2078 you may accept compensation in exchange for copies. If you 2079 distribute a large enough number of copies you must also follow the 2080 conditions in section 3. 2081 2082 You may also lend copies, under the same conditions stated above, 2083 and you may publicly display copies. 2084 2085 3. COPYING IN QUANTITY 2086 2087 If you publish printed copies (or copies in media that commonly 2088 have printed covers) of the Document, numbering more than 100, and 2089 the Document's license notice requires Cover Texts, you must 2090 enclose the copies in covers that carry, clearly and legibly, all 2091 these Cover Texts: Front-Cover Texts on the front cover, and 2092 Back-Cover Texts on the back cover. Both covers must also clearly 2093 and legibly identify you as the publisher of these copies. The 2094 front cover must present the full title with all words of the title 2095 equally prominent and visible. You may add other material on the 2096 covers in addition. Copying with changes limited to the covers, as 2097 long as they preserve the title of the Document and satisfy these 2098 conditions, can be treated as verbatim copying in other respects. 2099 2100 If the required texts for either cover are too voluminous to fit 2101 legibly, you should put the first ones listed (as many as fit 2102 reasonably) on the actual cover, and continue the rest onto 2103 adjacent pages. 2104 2105 If you publish or distribute Opaque copies of the Document 2106 numbering more than 100, you must either include a machine-readable 2107 Transparent copy along with each Opaque copy, or state in or with 2108 each Opaque copy a computer-network location from which the general 2109 network-using public has access to download using public-standard 2110 network protocols a complete Transparent copy of the Document, free 2111 of added material. If you use the latter option, you must take 2112 reasonably prudent steps, when you begin distribution of Opaque 2113 copies in quantity, to ensure that this Transparent copy will 2114 remain thus accessible at the stated location until at least one 2115 year after the last time you distribute an Opaque copy (directly or 2116 through your agents or retailers) of that edition to the public. 2117 2118 It is requested, but not required, that you contact the authors of 2119 the Document well before redistributing any large number of copies, 2120 to give them a chance to provide you with an updated version of the 2121 Document. 2122 2123 4. MODIFICATIONS 2124 2125 You may copy and distribute a Modified Version of the Document 2126 under the conditions of sections 2 and 3 above, provided that you 2127 release the Modified Version under precisely this License, with the 2128 Modified Version filling the role of the Document, thus licensing 2129 distribution and modification of the Modified Version to whoever 2130 possesses a copy of it. In addition, you must do these things in 2131 the Modified Version: 2132 2133 A. Use in the Title Page (and on the covers, if any) a title 2134 distinct from that of the Document, and from those of previous 2135 versions (which should, if there were any, be listed in the 2136 History section of the Document). You may use the same title 2137 as a previous version if the original publisher of that 2138 version gives permission. 2139 2140 B. List on the Title Page, as authors, one or more persons or 2141 entities responsible for authorship of the modifications in 2142 the Modified Version, together with at least five of the 2143 principal authors of the Document (all of its principal 2144 authors, if it has fewer than five), unless they release you 2145 from this requirement. 2146 2147 C. State on the Title page the name of the publisher of the 2148 Modified Version, as the publisher. 2149 2150 D. Preserve all the copyright notices of the Document. 2151 2152 E. Add an appropriate copyright notice for your modifications 2153 adjacent to the other copyright notices. 2154 2155 F. Include, immediately after the copyright notices, a license 2156 notice giving the public permission to use the Modified 2157 Version under the terms of this License, in the form shown in 2158 the Addendum below. 2159 2160 G. Preserve in that license notice the full lists of Invariant 2161 Sections and required Cover Texts given in the Document's 2162 license notice. 2163 2164 H. Include an unaltered copy of this License. 2165 2166 I. Preserve the section Entitled "History", Preserve its Title, 2167 and add to it an item stating at least the title, year, new 2168 authors, and publisher of the Modified Version as given on the 2169 Title Page. If there is no section Entitled "History" in the 2170 Document, create one stating the title, year, authors, and 2171 publisher of the Document as given on its Title Page, then add 2172 an item describing the Modified Version as stated in the 2173 previous sentence. 2174 2175 J. Preserve the network location, if any, given in the Document 2176 for public access to a Transparent copy of the Document, and 2177 likewise the network locations given in the Document for 2178 previous versions it was based on. These may be placed in the 2179 "History" section. You may omit a network location for a work 2180 that was published at least four years before the Document 2181 itself, or if the original publisher of the version it refers 2182 to gives permission. 2183 2184 K. For any section Entitled "Acknowledgements" or "Dedications", 2185 Preserve the Title of the section, and preserve in the section 2186 all the substance and tone of each of the contributor 2187 acknowledgements and/or dedications given therein. 2188 2189 L. Preserve all the Invariant Sections of the Document, unaltered 2190 in their text and in their titles. Section numbers or the 2191 equivalent are not considered part of the section titles. 2192 2193 M. Delete any section Entitled "Endorsements". Such a section 2194 may not be included in the Modified Version. 2195 2196 N. Do not retitle any existing section to be Entitled 2197 "Endorsements" or to conflict in title with any Invariant 2198 Section. 2199 2200 O. Preserve any Warranty Disclaimers. 2201 2202 If the Modified Version includes new front-matter sections or 2203 appendices that qualify as Secondary Sections and contain no 2204 material copied from the Document, you may at your option designate 2205 some or all of these sections as invariant. To do this, add their 2206 titles to the list of Invariant Sections in the Modified Version's 2207 license notice. These titles must be distinct from any other 2208 section titles. 2209 2210 You may add a section Entitled "Endorsements", provided it contains 2211 nothing but endorsements of your Modified Version by various 2212 parties--for example, statements of peer review or that the text 2213 has been approved by an organization as the authoritative 2214 definition of a standard. 2215 2216 You may add a passage of up to five words as a Front-Cover Text, 2217 and a passage of up to 25 words as a Back-Cover Text, to the end of 2218 the list of Cover Texts in the Modified Version. Only one passage 2219 of Front-Cover Text and one of Back-Cover Text may be added by (or 2220 through arrangements made by) any one entity. If the Document 2221 already includes a cover text for the same cover, previously added 2222 by you or by arrangement made by the same entity you are acting on 2223 behalf of, you may not add another; but you may replace the old 2224 one, on explicit permission from the previous publisher that added 2225 the old one. 2226 2227 The author(s) and publisher(s) of the Document do not by this 2228 License give permission to use their names for publicity for or to 2229 assert or imply endorsement of any Modified Version. 2230 2231 5. COMBINING DOCUMENTS 2232 2233 You may combine the Document with other documents released under 2234 this License, under the terms defined in section 4 above for 2235 modified versions, provided that you include in the combination all 2236 of the Invariant Sections of all of the original documents, 2237 unmodified, and list them all as Invariant Sections of your 2238 combined work in its license notice, and that you preserve all 2239 their Warranty Disclaimers. 2240 2241 The combined work need only contain one copy of this License, and 2242 multiple identical Invariant Sections may be replaced with a single 2243 copy. If there are multiple Invariant Sections with the same name 2244 but different contents, make the title of each such section unique 2245 by adding at the end of it, in parentheses, the name of the 2246 original author or publisher of that section if known, or else a 2247 unique number. Make the same adjustment to the section titles in 2248 the list of Invariant Sections in the license notice of the 2249 combined work. 2250 2251 In the combination, you must combine any sections Entitled 2252 "History" in the various original documents, forming one section 2253 Entitled "History"; likewise combine any sections Entitled 2254 "Acknowledgements", and any sections Entitled "Dedications". You 2255 must delete all sections Entitled "Endorsements." 2256 2257 6. COLLECTIONS OF DOCUMENTS 2258 2259 You may make a collection consisting of the Document and other 2260 documents released under this License, and replace the individual 2261 copies of this License in the various documents with a single copy 2262 that is included in the collection, provided that you follow the 2263 rules of this License for verbatim copying of each of the documents 2264 in all other respects. 2265 2266 You may extract a single document from such a collection, and 2267 distribute it individually under this License, provided you insert 2268 a copy of this License into the extracted document, and follow this 2269 License in all other respects regarding verbatim copying of that 2270 document. 2271 2272 7. AGGREGATION WITH INDEPENDENT WORKS 2273 2274 A compilation of the Document or its derivatives with other 2275 separate and independent documents or works, in or on a volume of a 2276 storage or distribution medium, is called an "aggregate" if the 2277 copyright resulting from the compilation is not used to limit the 2278 legal rights of the compilation's users beyond what the individual 2279 works permit. When the Document is included in an aggregate, this 2280 License does not apply to the other works in the aggregate which 2281 are not themselves derivative works of the Document. 2282 2283 If the Cover Text requirement of section 3 is applicable to these 2284 copies of the Document, then if the Document is less than one half 2285 of the entire aggregate, the Document's Cover Texts may be placed 2286 on covers that bracket the Document within the aggregate, or the 2287 electronic equivalent of covers if the Document is in electronic 2288 form. Otherwise they must appear on printed covers that bracket 2289 the whole aggregate. 2290 2291 8. TRANSLATION 2292 2293 Translation is considered a kind of modification, so you may 2294 distribute translations of the Document under the terms of section 2295 4. Replacing Invariant Sections with translations requires special 2296 permission from their copyright holders, but you may include 2297 translations of some or all Invariant Sections in addition to the 2298 original versions of these Invariant Sections. You may include a 2299 translation of this License, and all the license notices in the 2300 Document, and any Warranty Disclaimers, provided that you also 2301 include the original English version of this License and the 2302 original versions of those notices and disclaimers. In case of a 2303 disagreement between the translation and the original version of 2304 this License or a notice or disclaimer, the original version will 2305 prevail. 2306 2307 If a section in the Document is Entitled "Acknowledgements", 2308 "Dedications", or "History", the requirement (section 4) to 2309 Preserve its Title (section 1) will typically require changing the 2310 actual title. 2311 2312 9. TERMINATION 2313 2314 You may not copy, modify, sublicense, or distribute the Document 2315 except as expressly provided under this License. Any attempt 2316 otherwise to copy, modify, sublicense, or distribute it is void, 2317 and will automatically terminate your rights under this License. 2318 2319 However, if you cease all violation of this License, then your 2320 license from a particular copyright holder is reinstated (a) 2321 provisionally, unless and until the copyright holder explicitly and 2322 finally terminates your license, and (b) permanently, if the 2323 copyright holder fails to notify you of the violation by some 2324 reasonable means prior to 60 days after the cessation. 2325 2326 Moreover, your license from a particular copyright holder is 2327 reinstated permanently if the copyright holder notifies you of the 2328 violation by some reasonable means, this is the first time you have 2329 received notice of violation of this License (for any work) from 2330 that copyright holder, and you cure the violation prior to 30 days 2331 after your receipt of the notice. 2332 2333 Termination of your rights under this section does not terminate 2334 the licenses of parties who have received copies or rights from you 2335 under this License. If your rights have been terminated and not 2336 permanently reinstated, receipt of a copy of some or all of the 2337 same material does not give you any rights to use it. 2338 2339 10. FUTURE REVISIONS OF THIS LICENSE 2340 2341 The Free Software Foundation may publish new, revised versions of 2342 the GNU Free Documentation License from time to time. Such new 2343 versions will be similar in spirit to the present version, but may 2344 differ in detail to address new problems or concerns. See 2345 <http://www.gnu.org/copyleft/>. 2346 2347 Each version of the License is given a distinguishing version 2348 number. If the Document specifies that a particular numbered 2349 version of this License "or any later version" applies to it, you 2350 have the option of following the terms and conditions either of 2351 that specified version or of any later version that has been 2352 published (not as a draft) by the Free Software Foundation. If the 2353 Document does not specify a version number of this License, you may 2354 choose any version ever published (not as a draft) by the Free 2355 Software Foundation. If the Document specifies that a proxy can 2356 decide which future versions of this License can be used, that 2357 proxy's public statement of acceptance of a version permanently 2358 authorizes you to choose that version for the Document. 2359 2360 11. RELICENSING 2361 2362 "Massive Multiauthor Collaboration Site" (or "MMC Site") means any 2363 World Wide Web server that publishes copyrightable works and also 2364 provides prominent facilities for anybody to edit those works. A 2365 public wiki that anybody can edit is an example of such a server. 2366 A "Massive Multiauthor Collaboration" (or "MMC") contained in the 2367 site means any set of copyrightable works thus published on the MMC 2368 site. 2369 2370 "CC-BY-SA" means the Creative Commons Attribution-Share Alike 3.0 2371 license published by Creative Commons Corporation, a not-for-profit 2372 corporation with a principal place of business in San Francisco, 2373 California, as well as future copyleft versions of that license 2374 published by that same organization. 2375 2376 "Incorporate" means to publish or republish a Document, in whole or 2377 in part, as part of another Document. 2378 2379 An MMC is "eligible for relicensing" if it is licensed under this 2380 License, and if all works that were first published under this 2381 License somewhere other than this MMC, and subsequently 2382 incorporated in whole or in part into the MMC, (1) had no cover 2383 texts or invariant sections, and (2) were thus incorporated prior 2384 to November 1, 2008. 2385 2386 The operator of an MMC Site may republish an MMC contained in the 2387 site under CC-BY-SA on the same site at any time before August 1, 2388 2009, provided the MMC is eligible for relicensing. 2389 2390ADDENDUM: How to use this License for your documents 2391==================================================== 2392 2393To use this License in a document you have written, include a copy of 2394the License in the document and put the following copyright and license 2395notices just after the title page: 2396 2397 Copyright (C) YEAR YOUR NAME. 2398 Permission is granted to copy, distribute and/or modify this document 2399 under the terms of the GNU Free Documentation License, Version 1.3 2400 or any later version published by the Free Software Foundation; 2401 with no Invariant Sections, no Front-Cover Texts, and no Back-Cover 2402 Texts. A copy of the license is included in the section entitled ``GNU 2403 Free Documentation License''. 2404 2405 If you have Invariant Sections, Front-Cover Texts and Back-Cover 2406Texts, replace the "with...Texts." line with this: 2407 2408 with the Invariant Sections being LIST THEIR TITLES, with 2409 the Front-Cover Texts being LIST, and with the Back-Cover Texts 2410 being LIST. 2411 2412 If you have Invariant Sections without Cover Texts, or some other 2413combination of the three, merge those two alternatives to suit the 2414situation. 2415 2416 If your document contains nontrivial examples of program code, we 2417recommend releasing these examples in parallel under your choice of free 2418software license, such as the GNU General Public License, to permit 2419their use in free software. 2420 2421 2422 2423Tag Table: 2424Node: Top719 2425Node: Introduction2101 2426Node: Compiling4592 2427Node: Executing8648 2428Node: Invoking11436 2429Node: Output Options12851 2430Node: Analysis Options19942 2431Node: Miscellaneous Options23862 2432Node: Deprecated Options25116 2433Node: Symspecs27179 2434Node: Output29005 2435Node: Flat Profile30045 2436Node: Call Graph34998 2437Node: Primary38230 2438Node: Callers40818 2439Node: Subroutines42936 2440Node: Cycles44777 2441Node: Line-by-line51554 2442Node: Annotated Source55628 2443Node: Inaccuracy58625 2444Node: Sampling Error58883 2445Node: Assumptions61787 2446Node: How do I?63257 2447Node: Incompatibilities64814 2448Node: Details66308 2449Node: Implementation66701 2450Node: File Format72600 2451Node: Internals76892 2452Node: Debugging85382 2453Node: GNU Free Documentation License86972 2454 2455End Tag Table 2456