/hphp/tools/perf-call-graph.php

https://gitlab.com/iranjith4/hhvm · PHP · 159 lines · 116 code · 26 blank · 17 comment · 22 complexity · 2569bd471557e542f34937fc2c0da564 MD5 · raw file 

    

  1. #!/usr/local/bin/php -j
    2. 

  2. <?php
    3. 

  3. 

  4. require(__DIR__.'/perf-lib.php');
    5. 

  5. 

  6. # Returns true iff $sample contains a line containing $func.
    7. 

  7. function contains_frame(Vector $sample, string $func): bool {
    8. 

  8.   foreach ($sample as $frame) {
    9. 

  9.     if (strstr($frame, $func) !== false) return true;
    10. 

  10.   }
    11. 

  11.   return false;
    12. 

  12. }
    13. 

  13. 

  14. # Node is used to construct to call graph. It contains an inclusive count of
    15. 

  15. # samples for itself and all of its children, along with a map from function
    16. 

  16. # names to children.
    17. 

  17. class Node {
    18. 

  18.   private $kids = Map {};
    19. 

  19. 

  20.   public function __construct(private $name, private $count = 0) {}
    21. 

  21. 

  22.   # Add an edge from this function to $name, increasing the count of the child
    23. 

  23.   # Node by one and returning it.
    24. 

  24.   public function followEdge($name) {
    25. 

  25.     if (!isset($this->kids[$name])) $this->kids[$name] = new Node($name);
    26. 

  26. 

  27.     $new_node = $this->kids[$name];
    28. 

  28.     ++$new_node->count;
    29. 

  29.     return $new_node;
    30. 

  30.   }
    31. 

  31. 

  32.   # Print out the current node and all children.
    33. 

  33.   public function show(
    34. 

  34.     $total_count = null,
    35. 

  35.     $indent = '',
    36. 

  36.   ) {
    37. 

  37.     if ($total_count === null) {
    38. 

  38.       # We're the parent node and don't contain a useful name.
    39. 

  39.       $total_count = $this->count;
    40. 

  40.     } else {
    41. 

  41.       # Prune any subtrees that are <0.5% of the total to keep the output
    42. 

  42.       # readable.
    43. 

  43.       if ($this->count / $total_count < 0.005) return;
    44. 

  44.       printf("%s%.1f%% %s\n",
    45. 

  45.              $indent,
    46. 

  46.              $this->count / $total_count * 100,
    47. 

  47.              $this->name);
    48. 

  48.       $indent .= '- ';
    49. 

  49.     }
    50. 

  50. 

  51.     $items = $this->kids->items()->toVector();
    52. 

  52.     if ($items->count() == 0) return;
    53. 

  53. 

  54.     # If our only printable child is the body of this function, leave it out to
    55. 

  55.     # keep the results clean.
    56. 

  56.     if ($items[0][0] == '<body>' &&
    57. 

  57.         ($items->count() == 1 || $items[1][1]->count / $total_count < 0.005)) {
    58. 

  58.       return;
    59. 

  59.     }
    60. 

  60. 

  61.     usort($items, ($a, $b) ==> $b[1]->count - $a[1]->count);
    62. 

  62.     foreach ($items as $pair) {
    63. 

  63.       $pair[1]->show($total_count, $indent);
    64. 

  64.     }
    65. 

  65.   }
    66. 

  66. }
    67. 

  67. 

  68. # Build and print a perf-annotated call graph of each stack trace in $samples,
    69. 

  69. # truncated at the highest frame containing $top.
    70. 

  70. function treeify($samples, $top) {
    71. 

  71.   $root = new Node('', $samples->count());
    72. 

  72. 

  73.   foreach ($samples as $stack) {
    74. 

  74.     for ($i = $stack->count() - 1; $i >= 0; --$i) {
    75. 

  75.       if (strpos($stack[$i], $top) !== false) break;
    76. 

  76.     }
    77. 

  77. 

  78.     $node = $root;
    79. 

  79.     for (; $i >= 0; --$i) {
    80. 

  80.       $node = $node->followEdge($stack[$i]);
    81. 

  81.     }
    82. 

  82.     # Add a final entry for exclusive time spent in the body of the bottom
    83. 

  83.     # function.
    84. 

  84.     $node->followEdge('<body>');
    85. 

  85.   }
    86. 

  86. 

  87.   $root->show();
    88. 

  88. }
    89. 

  89. 

  90. function usage($script_name) {
    91. 

  91.   echo <<<EOT
    92. 

  92. Usage:
    93. 

  93. 

  94. $script_name [symbol]
    95. 

  95. 

  96. This script expects the output of "perf script -f comm,ip,sym" on stdin. If the
    97. 

  97. optional symbol argument is present, a call graph of all frames containing that
    98. 

  98. symbol will be output, with the root of the frame truncated at the highest
    99. 

  99. frame containing the symbol. Note that the symbol may appear anywhere in the
    100. 

  100. function name, so using 'Foo::translate' will match both 'Foo::translate' and
    101. 

  101. 'Foo::translateFrob'. If you just want Foo::translate, use 'Foo::translate('.
    102. 

  102. If symbol is not present, the total number of samples present will be printed
    103. 

  103. along with the number of samples that contain a few hardcoded functions.
    104. 

  104. 

  105. 

  106. EOT;
    107. 

  107. }
    108. 

  108. 

  109. function main($argv) {
    110. 

  110.   ini_set('memory_limit', '64G');
    111. 

  111.   if (posix_isatty(STDIN)) {
    112. 

  112.     usage($argv[0]);
    113. 

  113.     return 1;
    114. 

  114.   }
    115. 

  115. 

  116.   $samples = read_perf_samples(STDIN);
    117. 

  117. 

  118.   if (count($argv) == 2) {
    119. 

  119.     $functions = Set { $argv[1] };
    120. 

  120.   } else {
    121. 

  121.     $functions = Set {
    122. 

  122.       'MCGenerator::translate',
    123. 

  123.       'jit::selectTracelet(',
    124. 

  124.       'Translator::translateRegion(',
    125. 

  125.       'jit::optimizeRefcounts(',
    126. 

  126.       'jit::optimize(',
    127. 

  127.       'jit::allocateRegs(',
    128. 

  128.       'jit::genCode(',
    129. 

  129.       'getStackValue(',
    130. 

  130.       'IRBuilder::constrain',
    131. 

  131.       'relaxGuards(',
    132. 

  132.       'MCGenerator::retranslateOpt(',
    133. 

  133.       'IRTranslator::translateInstr(',
    134. 

  134.       'Type::subtypeOf(',
    135. 

  135.       'jit::regionizeFunc',
    136. 

  136.     };
    137. 

  137.   }
    138. 

  138. 

  139.   $subsamples = Map {'all' => $samples};
    140. 

  140.   foreach ($functions as $f) {
    141. 

  141.     $subsamples[$f] = $samples->filter($s ==> contains_frame($s, $f));
    142. 

  142.   }
    143. 

  143. 

  144.   if (count($argv) == 2) {
    145. 

  145.     $sub = $subsamples[$argv[1]];
    146. 

  146.     printf("Looking for pattern *%s*. %d of %d total samples (%.2f%%)\n\n",
    147. 

  147.            $argv[1], $sub->count(), $samples->count(),
    148. 

  148.            $sub->count() / $samples->count() * 100);
    149. 

  149.     treeify($subsamples[$argv[1]], $argv[1]);
    150. 

  150.   } else {
    151. 

  151.     foreach ($subsamples as $k => $v) {
    152. 

  152.       printf("%5d %s\n", $v->count(), $k);
    153. 

  153.     }
    154. 

  154.   }
    155. 

  155. 

  156.   return 0;
    157. 

  157. }
    158. 

  158. 

  159. exit(main($argv));
    160.