1 Overhead calculation 1 Overhead calculation
2 -------------------- 2 --------------------
3 The overhead can be shown in two columns as 'C 3 The overhead can be shown in two columns as 'Children' and 'Self' when
4 perf collects callchains. The 'self' overhead 4 perf collects callchains. The 'self' overhead is simply calculated by
5 adding all period values of the entry - usuall 5 adding all period values of the entry - usually a function (symbol).
6 This is the value that perf shows traditionall 6 This is the value that perf shows traditionally and sum of all the
7 'self' overhead values should be 100%. 7 'self' overhead values should be 100%.
8 8
9 The 'children' overhead is calculated by addin 9 The 'children' overhead is calculated by adding all period values of
10 the child functions so that it can show the to 10 the child functions so that it can show the total overhead of the
11 higher level functions even if they don't dire 11 higher level functions even if they don't directly execute much.
12 'Children' here means functions that are calle 12 'Children' here means functions that are called from another (parent)
13 function. 13 function.
14 14
15 It might be confusing that the sum of all the 15 It might be confusing that the sum of all the 'children' overhead
16 values exceeds 100% since each of them is alre 16 values exceeds 100% since each of them is already an accumulation of
17 'self' overhead of its child functions. But w 17 'self' overhead of its child functions. But with this enabled, users
18 can find which function has the most overhead 18 can find which function has the most overhead even if samples are
19 spread over the children. 19 spread over the children.
20 20
21 Consider the following example; there are thre 21 Consider the following example; there are three functions like below.
22 22
23 ----------------------- 23 -----------------------
24 void foo(void) { 24 void foo(void) {
25 /* do something */ 25 /* do something */
26 } 26 }
27 27
28 void bar(void) { 28 void bar(void) {
29 /* do something */ 29 /* do something */
30 foo(); 30 foo();
31 } 31 }
32 32
33 int main(void) { 33 int main(void) {
34 bar() 34 bar()
35 return 0; 35 return 0;
36 } 36 }
37 ----------------------- 37 -----------------------
38 38
39 In this case 'foo' is a child of 'bar', and 'b 39 In this case 'foo' is a child of 'bar', and 'bar' is an immediate
40 child of 'main' so 'foo' also is a child of 'm 40 child of 'main' so 'foo' also is a child of 'main'. In other words,
41 'main' is a parent of 'foo' and 'bar', and 'ba 41 'main' is a parent of 'foo' and 'bar', and 'bar' is a parent of 'foo'.
42 42
43 Suppose all samples are recorded in 'foo' and 43 Suppose all samples are recorded in 'foo' and 'bar' only. When it's
44 recorded with callchains the output will show 44 recorded with callchains the output will show something like below
45 in the usual (self-overhead-only) output of pe 45 in the usual (self-overhead-only) output of perf report:
46 46
47 ---------------------------------- 47 ----------------------------------
48 Overhead Symbol 48 Overhead Symbol
49 ........ ..................... 49 ........ .....................
50 60.00% foo 50 60.00% foo
51 | 51 |
52 --- foo 52 --- foo
53 bar 53 bar
54 main 54 main
55 __libc_start_main 55 __libc_start_main
56 56
57 40.00% bar 57 40.00% bar
58 | 58 |
59 --- bar 59 --- bar
60 main 60 main
61 __libc_start_main 61 __libc_start_main
62 ---------------------------------- 62 ----------------------------------
63 63
64 When the --children option is enabled, the 'se 64 When the --children option is enabled, the 'self' overhead values of
65 child functions (i.e. 'foo' and 'bar') are add 65 child functions (i.e. 'foo' and 'bar') are added to the parents to
66 calculate the 'children' overhead. In this ca 66 calculate the 'children' overhead. In this case the report could be
67 displayed as: 67 displayed as:
68 68
69 ------------------------------------------- 69 -------------------------------------------
70 Children Self Symbol 70 Children Self Symbol
71 ........ ........ .................... 71 ........ ........ ....................
72 100.00% 0.00% __libc_start_main 72 100.00% 0.00% __libc_start_main
73 | 73 |
74 --- __libc_start_main 74 --- __libc_start_main
75 75
76 100.00% 0.00% main 76 100.00% 0.00% main
77 | 77 |
78 --- main 78 --- main
79 __libc_start_main 79 __libc_start_main
80 80
81 100.00% 40.00% bar 81 100.00% 40.00% bar
82 | 82 |
83 --- bar 83 --- bar
84 main 84 main
85 __libc_start_main 85 __libc_start_main
86 86
87 60.00% 60.00% foo 87 60.00% 60.00% foo
88 | 88 |
89 --- foo 89 --- foo
90 bar 90 bar
91 main 91 main
92 __libc_start_main 92 __libc_start_main
93 ------------------------------------------- 93 -------------------------------------------
94 94
95 In the above output, the 'self' overhead of 'f 95 In the above output, the 'self' overhead of 'foo' (60%) was add to the
96 'children' overhead of 'bar', 'main' and '\_\_ 96 'children' overhead of 'bar', 'main' and '\_\_libc_start_main'.
97 Likewise, the 'self' overhead of 'bar' (40%) w 97 Likewise, the 'self' overhead of 'bar' (40%) was added to the
98 'children' overhead of 'main' and '\_\_libc_st 98 'children' overhead of 'main' and '\_\_libc_start_main'.
99 99
100 So '\_\_libc_start_main' and 'main' are shown 100 So '\_\_libc_start_main' and 'main' are shown first since they have
101 same (100%) 'children' overhead (even though t 101 same (100%) 'children' overhead (even though they have zero 'self'
102 overhead) and they are the parents of 'foo' an 102 overhead) and they are the parents of 'foo' and 'bar'.
103 103
104 Since v3.16 the 'children' overhead is shown b 104 Since v3.16 the 'children' overhead is shown by default and the output
105 is sorted by its values. The 'children' overhe 105 is sorted by its values. The 'children' overhead is disabled by
106 specifying --no-children option on the command 106 specifying --no-children option on the command line or by adding
107 'report.children = false' or 'top.children = f 107 'report.children = false' or 'top.children = false' in the perf config
108 file. 108 file.
Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.