Lines Matching refs:each
137 of each caller. The profile data is taken from the call graph profile file
148 @code{Gprof} calculates the amount of time spent in each routine.
158 We assume that the time for each execution of a function
243 The @dfn{flat profile} shows how much time your program spent in each function,
248 The @dfn{call graph} shows, for each function, which functions called it, which
250 of how much time was spent in the subroutines of each function. This can
255 source code, labeled with the number of times each line of the
493 print a tally of functions and the number of times each was called.
559 each source file to be listed when source annotation is enabled. The
578 print a tally of functions and the number of times each was called.
704 this option will also identify how many times each line of
713 This option causes @code{gprof} to print the source file after each
801 given; only one @var{function_name} may be indicated with each @samp{-e}
809 @var{function_name} may be indicated with each @samp{-E} option.
815 only one @var{function_name} may be indicated with each @samp{-f}
823 may be given; only one @var{function_name} may be indicated with each
830 Note that only one function can be specified with each @code{-e},
907 executing directly in each function.
909 others, and how much time each function used
922 spent executing each function. Unless the @samp{-z} option is given,
964 how much time each sample counted as.
965 This @dfn{sampling period} estimates the margin of error in each of the time
967 reliable. In this example, each sample counted as 0.01 seconds,
971 each sample counted for 0.01 seconds, this means only six samples
975 occurred one each in @samp{offtime}, @samp{memccpy}, @samp{write},
992 determination of how much time each took.
994 Here is what the fields in each line mean:
1037 The @dfn{call graph} shows how much time was spent in each function
1048 granularity: each sample hit covers 2 byte(s) for 20.00% of 0.05 seconds
1079 The lines full of dashes divide this table into @dfn{entries}, one for each
1082 In each entry, the primary line is the one that starts with an index number
1180 A function's entry has a line for each function it was called by.
1238 A function's entry has a line for each of its subroutines---in other
1239 words, a line for each other function that it called. These lines'
1296 belong to the same cycle. If @code{a} and @code{b} call each other and
1297 @code{b} and @code{c} call each other, all three make one cycle. Note that
1303 belongs to a cycle, each time the function name appears in the call graph
1414 how many times each function in the cycle called or was called from each other
1441 The call graph does, however, show each line of code
1442 that called each function, along with a count.
1460 granularity: each sample hit covers 4 byte(s) for 7.69% of 0.13 seconds
1475 occurred on each of lines 349, 351, 382 and 385. In the call graph,
1496 granularity: each sample hit covers 4 byte(s) for 7.69% of 0.13 seconds
1521 which lists the program's source code, each function labeled with the
1528 determine how many times each line of code was executed. With newer
1561 for each branch of the @code{if}. A fourth basic-block results from
1569 to ensure that each line of code is labeled at least once.
1596 each branch of the @code{if} statement. The body of the @code{do}
1599 each iteration through the loop. One of those times (the last time)
1696 The assumption made is that the average time spent in each call to any
1757 each run will appear with a call count of 100).
1842 and the number of times each of these call arcs was traversed.
1909 the starting address of each basic-block. Taken together,
1953 records. Each file can contain any number of each record type. When
1955 compatible with each other and compute the union of all records. For
1957 of all execution counts for each basic-block.
1980 Histogram bins are 16-bit numbers and each bin represent an equal
1982 thousand bytes long and if there are ten bins in the histogram, each
2020 pair each for the flat profile (INCL_FLAT/EXCL_FLAT),
2077 (@code{syms}) is created, each entry of which is a symbol table
2082 count the size of each required symbol table, and again to build
2099 records) are read, the memory ranges of each pair of histogram records
2100 must be either equal, or non-overlapping. For each pair of histogram
2106 As each call graph record is read (@code{call_graph.c:@-cg_read_rec}),
2110 check against INCL_ARCS/EXCL_ARCS. As each arc is added,
2136 to each symbol, proportional to the degree of overlap.
2139 cause each of two adjacent lines to be credited with half
2144 routine (@code{find_call}) scans through each symbol's machine code,
2157 computes the fraction of child time to propagate to each parent
2175 information, if present, to label each line of code with call counts,
2200 As the call graph arcs are read, show each arc and how
2201 the total calls to each function are tallied
2203 Details sorting individual parents/children within each call graph entry
2205 Shows address ranges of histograms as they are read, and each