ceph/src/boost/libs/serialization/doc/profile1.txt

   1 Flat profile:
   2
   3 Each sample counts as 0.01 seconds.
   4  no time accumulated
   5
   6   %   cumulative   self              self     total
   7  time   seconds   seconds    calls  Ts/call  Ts/call  name
   8   0.00      0.00     0.00      200     0.00     0.00  void accumulate<unsigned long>(unsigned int&, unsigned long const&)
   9   0.00      0.00     0.00      150     0.00     0.00  _pei386_runtime_relocator
  10   0.00      0.00     0.00        1     0.00     0.00  std::ostream::operator<<(void const*)
  11   0.00      0.00     0.00        1     0.00     0.00  __divdi3
  12
  13  %         the percentage of the total running time of the
  14 time       program used by this function.
  15
  16 cumulative a running sum of the number of seconds accounted
  17  seconds   for by this function and those listed above it.
  18
  19  self      the number of seconds accounted for by this
  20 seconds    function alone.  This is the major sort for this
  21            listing.
  22
  23 calls      the number of times this function was invoked, if
  24            this function is profiled, else blank.
  25
  26  self      the average number of milliseconds spent in this
  27 ms/call    function per call, if this function is profiled,
  28            else blank.
  29
  30  total     the average number of milliseconds spent in this
  31 ms/call    function and its descendents per call, if this
  32            function is profiled, else blank.
  33
  34 name       the name of the function.  This is the minor sort
  35            for this listing. The index shows the location of
  36            the function in the gprof listing. If the index is
  37            in parenthesis it shows where it would appear in
  38            the gprof listing if it were to be printed.
  39 \f
  40                      Call graph (explanation follows)
  41
  42
  43 granularity: each sample hit covers 4 byte(s) no time propagated
  44
  45 index % time    self  children    called     name
  46                 0.00    0.00     200/200         setvbuf [1286]
  47 [4]      0.0    0.00    0.00     200         void accumulate<unsigned long>(unsigned int&, unsigned long const&) [4]
  48 -----------------------------------------------
  49                 0.00    0.00     150/150         _cygwin_crt0_common@8 [1230]
  50 [5]      0.0    0.00    0.00     150         _pei386_runtime_relocator [5]
  51 -----------------------------------------------
  52                 0.00    0.00       1/1           _lseek64 [1234]
  53 [6]      0.0    0.00    0.00       1         std::ostream::operator<<(void const*) [6]
  54 -----------------------------------------------
  55                 0.00    0.00       1/1           __tcf_1 [1221]
  56 [7]      0.0    0.00    0.00       1         __divdi3 [7]
  57 -----------------------------------------------
  58                                    2             main [1263]
  59 [1263]   0.0    0.00    0.00       0+2       main [1263]
  60                                    2             main [1263]
  61 -----------------------------------------------
  62
  63  This table describes the call tree of the program, and was sorted by
  64  the total amount of time spent in each function and its children.
  65
  66  Each entry in this table consists of several lines.  The line with the
  67  index number at the left hand margin lists the current function.
  68  The lines above it list the functions that called this function,
  69  and the lines below it list the functions this one called.
  70  This line lists:
  71      index      A unique number given to each element of the table.
  72                 Index numbers are sorted numerically.
  73                 The index number is printed next to every function name so
  74                 it is easier to look up where the function in the table.
  75
  76      % time     This is the percentage of the `total' time that was spent
  77                 in this function and its children.  Note that due to
  78                 different viewpoints, functions excluded by options, etc,
  79                 these numbers will NOT add up to 100%.
  80
  81      self       This is the total amount of time spent in this function.
  82
  83      children   This is the total amount of time propagated into this
  84                 function by its children.
  85
  86      called     This is the number of times the function was called.
  87                 If the function called itself recursively, the number
  88                 only includes non-recursive calls, and is followed by
  89                 a `+' and the number of recursive calls.
  90
  91      name       The name of the current function.  The index number is
  92                 printed after it.  If the function is a member of a
  93                 cycle, the cycle number is printed between the
  94                 function's name and the index number.
  95
  96
  97  For the function's parents, the fields have the following meanings:
  98
  99      self       This is the amount of time that was propagated directly
 100                 from the function into this parent.
 101
 102      children   This is the amount of time that was propagated from
 103                 the function's children into this parent.
 104
 105      called     This is the number of times this parent called the
 106                 function `/' the total number of times the function
 107                 was called.  Recursive calls to the function are not
 108                 included in the number after the `/'.
 109
 110      name       This is the name of the parent.  The parent's index
 111                 number is printed after it.  If the parent is a
 112                 member of a cycle, the cycle number is printed between
 113                 the name and the index number.
 114
 115  If the parents of the function cannot be determined, the word
 116  `<spontaneous>' is printed in the `name' field, and all the other
 117  fields are blank.
 118
 119  For the function's children, the fields have the following meanings:
 120
 121      self       This is the amount of time that was propagated directly
 122                 from the child into the function.
 123
 124      children   This is the amount of time that was propagated from the
 125                 child's children to the function.
 126
 127      called     This is the number of times the function called
 128                 this child `/' the total number of times the child
 129                 was called.  Recursive calls by the child are not
 130                 listed in the number after the `/'.
 131
 132      name       This is the name of the child.  The child's index
 133                 number is printed after it.  If the child is a
 134                 member of a cycle, the cycle number is printed
 135                 between the name and the index number.
 136
 137  If there are any cycles (circles) in the call graph, there is an
 138  entry for the cycle-as-a-whole.  This entry shows who called the
 139  cycle (as parents) and the members of the cycle (as children.)
 140  The `+' recursive calls entry shows the number of function calls that
 141  were internal to the cycle, and the calls entry for each member shows,
 142  for that member, how many times it was called from other members of
 143  the cycle.
 144
 145 \f
 146 Index by function name
 147
 148    [4] void accumulate<unsigned long>(unsigned int&, unsigned long const&) [7] __divdi3
 149    [6] std::ostream::operator<<(void const*) [5] _pei386_runtime_relocator