massif/ms_print.in

   1 #! @PERL@
   2
   3 ##--------------------------------------------------------------------##
   4 ##--- Massif's results printer                         ms_print.in ---##
   5 ##--------------------------------------------------------------------##
   6
   7 #  This file is part of Massif, a Valgrind tool for profiling memory
   8 #  usage of programs.
   9 #
  10 #  Copyright (C) 2007-2013 Nicholas Nethercote
  11 #     njn@valgrind.org
  12 #
  13 #  This program is free software; you can redistribute it and/or
  14 #  modify it under the terms of the GNU General Public License as
  15 #  published by the Free Software Foundation; either version 2 of the
  16 #  License, or (at your option) any later version.
  17 #
  18 #  This program is distributed in the hope that it will be useful, but
  19 #  WITHOUT ANY WARRANTY; without even the implied warranty of
  20 #  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  21 #  General Public License for more details.
  22 #
  23 #  You should have received a copy of the GNU General Public License
  24 #  along with this program; if not, write to the Free Software
  25 #  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
  26 #  02111-1307, USA.
  27 #
  28 #  The GNU General Public License is contained in the file COPYING.
  29
  30 use warnings;
  31 use strict;
  32
  33 #----------------------------------------------------------------------------
  34 # Global variables, main data structures
  35 #----------------------------------------------------------------------------
  36
  37 # Command line of profiled program.
  38 my $cmd;
  39
  40 # Time unit used in profile.
  41 my $time_unit;
  42
  43 # Threshold dictating what percentage an entry must represent for us to
  44 # bother showing it.
  45 my $threshold = 1.0;
  46
  47 # Graph x and y dimensions.
  48 my $graph_x = 72;
  49 my $graph_y = 20;
  50
  51 # Input file name
  52 my $input_file = undef;
  53
  54 # Where to create tmp files. See also function VG_(tmpdir) in m_libcfile.c.
  55 my $tmp_dir = $ENV{"TMPDIR"};
  56 $tmp_dir = "@VG_TMPDIR@" if (! $tmp_dir);
  57 $tmp_dir = "/tmp" if (! $tmp_dir);
  58
  59 # Tmp file name.
  60 my $tmp_file = "$tmp_dir/ms_print.tmp.$$";
  61
  62 # Version number.
  63 my $version = "@VERSION@";
  64
  65 # Args passed, for printing.
  66 my $ms_print_args;
  67
  68 # Usage message.
  69 my $usage = <<END
  70 usage: ms_print [options] massif-out-file
  71
  72   options for the user, with defaults in [ ], are:
  73     -h --help             show this message
  74     --version             show version
  75     --threshold=<m.n>     significance threshold, in percent [$threshold]
  76     --x=<4..1000>         graph width, in columns [72]
  77     --y=<4..1000>         graph height, in rows [20]
  78
  79   ms_print is Copyright (C) 2007-2013 Nicholas Nethercote.
  80   and licensed under the GNU General Public License, version 2.
  81   Bug reports, feedback, admiration, abuse, etc, to: njn\@valgrind.org.
  82
  83 END
  84 ;
  85
  86 # Used in various places of output.
  87 my $fancy    = '-' x 80;
  88 my $fancy_nl = $fancy . "\n";
  89
  90 # Returns 0 if the denominator is 0.
  91 sub safe_div_0($$)
  92 {
  93     my ($x, $y) = @_;
  94     return ($y ? $x / $y : 0);
  95 }
  96
  97 #-----------------------------------------------------------------------------
  98 # Argument and option handling
  99 #-----------------------------------------------------------------------------
 100 sub process_cmd_line()
 101 {
 102     my @files;
 103
 104     # Grab a copy of the arguments, for printing later.
 105     for my $arg (@ARGV) {
 106         $ms_print_args .= " $arg";       # The arguments.
 107     }
 108
 109     for my $arg (@ARGV) {
 110
 111         # Option handling
 112         if ($arg =~ /^-/) {
 113
 114             # --version
 115             if ($arg =~ /^--version$/) {
 116                 die("ms_print-$version\n");
 117
 118             # --threshold=X (tolerates a trailing '%')
 119             } elsif ($arg =~ /^--threshold=([\d\.]+)%?$/) {
 120                 $threshold = $1;
 121                 ($1 >= 0 && $1 <= 100) or die($usage);
 122
 123             } elsif ($arg =~ /^--x=(\d+)$/) {
 124                 $graph_x = $1;
 125                 (4 <= $graph_x && $graph_x <= 1000) or die($usage);
 126
 127             } elsif ($arg =~ /^--y=(\d+)$/) {
 128                 $graph_y = $1;
 129                 (4 <= $graph_y && $graph_y <= 1000) or die($usage);
 130
 131             } else {            # -h and --help fall under this case
 132                 die($usage);
 133             }
 134         } else {
 135             # Not an option.  Remember it as a filename.
 136             push(@files, $arg);
 137         }
 138     }
 139
 140     # Must have chosen exactly one input file.
 141     if (scalar @files) {
 142         $input_file = $files[0];
 143     } else {
 144         die($usage);
 145     }
 146 }
 147
 148 #-----------------------------------------------------------------------------
 149 # Reading the input file: auxiliary functions
 150 #-----------------------------------------------------------------------------
 151
 152 # Gets the next line, stripping comments and skipping blanks.
 153 # Returns undef at EOF.
 154 sub get_line()
 155 {
 156     while (my $line = <INPUTFILE>) {
 157         $line =~ s/#.*$//;          # remove comments
 158         if ($line !~ /^\s*$/) {
 159             return $line;           # return $line if non-empty
 160         }
 161     }
 162     return undef;       # EOF: return undef
 163 }
 164
 165 sub equals_num_line($$)
 166 {
 167     my ($line, $fieldname) = @_;
 168     defined($line)
 169         or die("Line $.: expected \"$fieldname\" line, got end of file\n");
 170     $line =~ s/^$fieldname=(.*)\s*$//
 171         or die("Line $.: expected \"$fieldname\" line, got:\n$line");
 172     return $1;
 173 }
 174
 175 sub is_significant_XPt($$$)
 176 {
 177     my ($is_top_node, $xpt_szB, $total_szB) = @_;
 178     ($xpt_szB <= $total_szB) or die;
 179     # Nb: we always consider the alloc-XPt significant, even if the size is
 180     # zero.
 181     return $is_top_node || 0 == $threshold ||
 182         ( $total_szB != 0 && $xpt_szB * 100 / $total_szB >= $threshold );
 183 }
 184
 185 #-----------------------------------------------------------------------------
 186 # Reading the input file: reading heap trees
 187 #-----------------------------------------------------------------------------
 188
 189 # Forward declaration, because it's recursive.
 190 sub read_heap_tree($$$$$);
 191
 192 # Return pair:  if the tree was significant, both are zero.  If it was
 193 # insignificant, the first element is 1 and the second is the number of
 194 # bytes.
 195 sub read_heap_tree($$$$$)
 196 {
 197     # Read the line and determine if it is significant.
 198     my ($is_top_node, $this_prefix, $child_midfix, $arrow, $mem_total_B) = @_;
 199     my $line = get_line();
 200     (defined $line and $line =~ /^\s*n(\d+):\s*(\d+)(.*)$/)
 201         or die("Line $.: expected a tree node line, got:\n$line\n");
 202     my $n_children = $1;
 203     my $bytes      = $2;
 204     my $details    = $3;
 205     my $perc       = safe_div_0(100 * $bytes, $mem_total_B);
 206     # Nb: we always print the alloc-XPt, even if its size is zero.
 207     my $is_significant = is_significant_XPt($is_top_node, $bytes, $mem_total_B);
 208
 209     # We precede this node's line with "$this_prefix.$arrow".  We precede
 210     # any children of this node with "$this_prefix$child_midfix$arrow".
 211     if ($is_significant) {
 212         # Nb: $details might have '%' in it, so don't embed directly in the
 213         # format string.
 214         printf(TMPFILE
 215             "$this_prefix$arrow%05.2f%% (%sB)%s\n", $perc, commify($bytes),
 216             $details);
 217     }
 218
 219     # Now read all the children.
 220     my $n_insig_children = 0;
 221     my $total_insig_children_szB = 0;
 222     my $this_prefix2 = $this_prefix . $child_midfix;
 223     for (my $i = 0; $i < $n_children; $i++) {
 224         # If child is the last sibling, the midfix is empty.
 225         my $child_midfix2 = ( $i+1 == $n_children ? "  " : "| " );
 226         my ($is_child_insignificant, $child_insig_bytes) =
 227             # '0' means it's not the top node of the tree.
 228             read_heap_tree(0, $this_prefix2, $child_midfix2, "->",
 229                 $mem_total_B);
 230         $n_insig_children += $is_child_insignificant;
 231         $total_insig_children_szB += $child_insig_bytes;
 232     }
 233
 234     if ($is_significant) {
 235         # If this was significant but any children were insignificant, print
 236         # the "in N places" line for them.
 237         if ($n_insig_children > 0) {
 238             $perc = safe_div_0(100 * $total_insig_children_szB, $mem_total_B);
 239             printf(TMPFILE "%s->%05.2f%% (%sB) in %d+ places, all below "
 240                  . "ms_print's threshold (%05.2f%%)\n",
 241                 $this_prefix2, $perc, commify($total_insig_children_szB),
 242                 $n_insig_children, $threshold);
 243             print(TMPFILE "$this_prefix2\n");
 244         }
 245
 246         # If this node has no children, print an extra (mostly) empty line.
 247         if (0 == $n_children) {
 248             print(TMPFILE "$this_prefix2\n");
 249         }
 250         return (0, 0);
 251
 252     } else {
 253         return (1, $bytes);
 254     }
 255 }
 256
 257 #-----------------------------------------------------------------------------
 258 # Reading the input file: main
 259 #-----------------------------------------------------------------------------
 260
 261 sub max_label_2($$)
 262 {
 263     my ($szB, $szB_scaled) = @_;
 264
 265     # For the label, if $szB is 999B or below, we print it as an integer.
 266     # Otherwise, we print it as a float with 5 characters (including the '.').
 267     # Examples (for bytes):
 268     #       1 -->     1  B
 269     #     999 -->   999  B
 270     #    1000 --> 0.977 KB
 271     #    1024 --> 1.000 KB
 272     #   10240 --> 10.00 KB
 273     #  102400 --> 100.0 KB
 274     # 1024000 --> 0.977 MB
 275     # 1048576 --> 1.000 MB
 276     #
 277     if    ($szB < 1000)        { return sprintf("%5d",   $szB);        }
 278     elsif ($szB_scaled < 10)   { return sprintf("%5.3f", $szB_scaled); }
 279     elsif ($szB_scaled < 100)  { return sprintf("%5.2f", $szB_scaled); }
 280     else                       { return sprintf("%5.1f", $szB_scaled); }
 281 }
 282
 283 # Work out the units for the max value, measured in instructions.
 284 sub i_max_label($)
 285 {
 286     my ($nI) = @_;
 287
 288     # We repeat until the number is less than 1000.
 289     my $nI_scaled = $nI;
 290     my $unit = "i";
 291     # Nb: 'k' is the "kilo" (1000) prefix.
 292     if ($nI_scaled >= 1000) { $unit = "ki"; $nI_scaled /= 1024; }
 293     if ($nI_scaled >= 1000) { $unit = "Mi"; $nI_scaled /= 1024; }
 294     if ($nI_scaled >= 1000) { $unit = "Gi"; $nI_scaled /= 1024; }
 295     if ($nI_scaled >= 1000) { $unit = "Ti"; $nI_scaled /= 1024; }
 296     if ($nI_scaled >= 1000) { $unit = "Pi"; $nI_scaled /= 1024; }
 297     if ($nI_scaled >= 1000) { $unit = "Ei"; $nI_scaled /= 1024; }
 298     if ($nI_scaled >= 1000) { $unit = "Zi"; $nI_scaled /= 1024; }
 299     if ($nI_scaled >= 1000) { $unit = "Yi"; $nI_scaled /= 1024; }
 300
 301     return (max_label_2($nI, $nI_scaled), $unit);
 302 }
 303
 304 # Work out the units for the max value, measured in bytes.
 305 sub B_max_label($)
 306 {
 307     my ($szB) = @_;
 308
 309     # We repeat until the number is less than 1000, but we divide by 1024 on
 310     # each scaling.
 311     my $szB_scaled = $szB;
 312     my $unit = "B";
 313     # Nb: 'K' or 'k' are acceptable as the "binary kilo" (1024) prefix.
 314     # (Strictly speaking, should use "KiB" (kibibyte), "MiB" (mebibyte), etc,
 315     # but they're not in common use.)
 316     if ($szB_scaled >= 1000) { $unit = "KB"; $szB_scaled /= 1024; }
 317     if ($szB_scaled >= 1000) { $unit = "MB"; $szB_scaled /= 1024; }
 318     if ($szB_scaled >= 1000) { $unit = "GB"; $szB_scaled /= 1024; }
 319     if ($szB_scaled >= 1000) { $unit = "TB"; $szB_scaled /= 1024; }
 320     if ($szB_scaled >= 1000) { $unit = "PB"; $szB_scaled /= 1024; }
 321     if ($szB_scaled >= 1000) { $unit = "EB"; $szB_scaled /= 1024; }
 322     if ($szB_scaled >= 1000) { $unit = "ZB"; $szB_scaled /= 1024; }
 323     if ($szB_scaled >= 1000) { $unit = "YB"; $szB_scaled /= 1024; }
 324
 325     return (max_label_2($szB, $szB_scaled), $unit);
 326 }
 327
 328 # Work out the units for the max value, measured in ms/s/h.
 329 sub t_max_label($)
 330 {
 331     my ($szB) = @_;
 332
 333     # We scale from millisecond to seconds to hours.
 334     #
 335     # XXX: this allows a number with 6 chars, eg. "3599.0 s"
 336     my $szB_scaled = $szB;
 337     my $unit = "ms";
 338     if ($szB_scaled >= 1000) { $unit = "s"; $szB_scaled /= 1000; }
 339     if ($szB_scaled >= 3600) { $unit = "h"; $szB_scaled /= 3600; }
 340
 341     return (max_label_2($szB, $szB_scaled), $unit);
 342 }
 343
 344 # This prints four things:
 345 #   - the output header
 346 #   - the graph
 347 #   - the snapshot summaries (number, list of detailed ones)
 348 #   - the snapshots
 349 #
 350 # The first three parts can't be printed until we've read the whole input file;
 351 # but the fourth part is much easier to print while we're reading the file.  So
 352 # we print the fourth part to a tmp file, and then dump the tmp file at the
 353 # end.
 354 #
 355 sub read_input_file()
 356 {
 357     my $desc = "";              # Concatenated description lines.
 358     my $peak_mem_total_szB = 0;
 359
 360     # Info about each snapshot.
 361     my @snapshot_nums = ();
 362     my @times         = ();
 363     my @mem_total_Bs  = ();
 364     my @is_detaileds  = ();
 365     my $peak_num = -1;      # An initial value that will be ok if no peak
 366                             # entry is in the file.
 367
 368     #-------------------------------------------------------------------------
 369     # Read start of input file.
 370     #-------------------------------------------------------------------------
 371     open(INPUTFILE, "< $input_file")
 372          || die "Cannot open $input_file for reading\n";
 373
 374     # Read "desc:" lines.
 375     my $line;
 376     while ($line = get_line()) {
 377         if ($line =~ s/^desc://) {
 378             $desc .= $line;
 379         } else {
 380             last;
 381         }
 382     }
 383
 384     # Read "cmd:" line (Nb: will already be in $line from "desc:" loop above).
 385     ($line =~ /^cmd:\s*(.*)$/) or die("Line $.: missing 'cmd' line\n");
 386     $cmd = $1;
 387
 388     # Read "time_unit:" line.
 389     $line = get_line();
 390     ($line =~ /^time_unit:\s*(.*)$/) or
 391         die("Line $.: missing 'time_unit' line\n");
 392     $time_unit = $1;
 393
 394     #-------------------------------------------------------------------------
 395     # Print snapshot list header to $tmp_file.
 396     #-------------------------------------------------------------------------
 397     open(TMPFILE, "> $tmp_file")
 398          || die "Cannot open $tmp_file for writing\n";
 399
 400     my $time_column = sprintf("%14s", "time($time_unit)");
 401     my $column_format = "%3s %14s %16s %16s %13s %12s\n";
 402     my $header =
 403         $fancy_nl .
 404         sprintf($column_format
 405         ,   "n"
 406         ,   $time_column
 407         ,   "total(B)"
 408         ,   "useful-heap(B)"
 409         ,   "extra-heap(B)"
 410         ,   "stacks(B)"
 411         ) .
 412         $fancy_nl;
 413     print(TMPFILE $header);
 414
 415     #-------------------------------------------------------------------------
 416     # Read body of input file.
 417     #-------------------------------------------------------------------------
 418     $line = get_line();
 419     while (defined $line) {
 420         my $snapshot_num     = equals_num_line($line,      "snapshot");
 421         my $time             = equals_num_line(get_line(), "time");
 422         my $mem_heap_B       = equals_num_line(get_line(), "mem_heap_B");
 423         my $mem_heap_extra_B = equals_num_line(get_line(), "mem_heap_extra_B");
 424         my $mem_stacks_B     = equals_num_line(get_line(), "mem_stacks_B");
 425         my $mem_total_B      = $mem_heap_B + $mem_heap_extra_B + $mem_stacks_B;
 426         my $heap_tree        = equals_num_line(get_line(), "heap_tree");
 427
 428         # Print the snapshot data to $tmp_file.
 429         printf(TMPFILE $column_format,
 430         ,   $snapshot_num
 431         ,   commify($time)
 432         ,   commify($mem_total_B)
 433         ,   commify($mem_heap_B)
 434         ,   commify($mem_heap_extra_B)
 435         ,   commify($mem_stacks_B)
 436         );
 437
 438         # Remember the snapshot data.
 439         push(@snapshot_nums, $snapshot_num);
 440         push(@times,         $time);
 441         push(@mem_total_Bs,  $mem_total_B);
 442         push(@is_detaileds,  ( $heap_tree eq "empty" ? 0 : 1 ));
 443         $peak_mem_total_szB = $mem_total_B
 444             if $mem_total_B > $peak_mem_total_szB;
 445
 446         # Read the heap tree, and if it's detailed, print it and a subsequent
 447         # snapshot list header to $tmp_file.
 448         if      ($heap_tree eq "empty") {
 449             $line = get_line();
 450         } elsif ($heap_tree =~ "(detailed|peak)") {
 451             # If "peak", remember the number.
 452             if ($heap_tree eq "peak") {
 453                 $peak_num = $snapshot_num;
 454             }
 455             # '1' means it's the top node of the tree.
 456             read_heap_tree(1, "", "", "", $mem_total_B);
 457
 458             # Print the header, unless there are no more snapshots.
 459             $line = get_line();
 460             if (defined $line) {
 461                 print(TMPFILE $header);
 462             }
 463         } else {
 464             die("Line $.: expected 'empty' or '...' after 'heap_tree='\n");
 465         }
 466     }
 467
 468     close(INPUTFILE);
 469     close(TMPFILE);
 470
 471     #-------------------------------------------------------------------------
 472     # Print header.
 473     #-------------------------------------------------------------------------
 474     print($fancy_nl);
 475     print("Command:            $cmd\n");
 476     print("Massif arguments:  $desc");
 477     print("ms_print arguments:$ms_print_args\n");
 478     print($fancy_nl);
 479     print("\n\n");
 480
 481     #-------------------------------------------------------------------------
 482     # Setup for graph.
 483     #-------------------------------------------------------------------------
 484     # The ASCII graph.
 485     # Row    0 ([0..graph_x][0]) is the X-axis.
 486     # Column 0 ([0][0..graph_y]) is the Y-axis.
 487     # The rest ([1][1]..[graph_x][graph_y]) is the usable graph area.
 488     my @graph;
 489     my $x;
 490     my $y;
 491
 492     my $n_snapshots = scalar(@snapshot_nums);
 493     ($n_snapshots > 0) or die;
 494     my $end_time = $times[$n_snapshots-1];
 495     ($end_time >= 0) or die;
 496
 497     # Setup graph[][].
 498     $graph[0][0] = '+';                                     # axes join point
 499     for ($x = 1; $x <= $graph_x; $x++) { $graph[$x][0] = '-'; } # X-axis
 500     for ($y = 1; $y <= $graph_y; $y++) { $graph[0][$y] = '|'; } # Y-axis
 501     $graph[$graph_x][0] = '>';                                  # X-axis arrow
 502     $graph[0][$graph_y] = '^';                                  # Y-axis arrow
 503     for ($x = 1; $x <= $graph_x; $x++) {                        # usable area
 504        for ($y = 1; $y <= $graph_y; $y++) {
 505           $graph[$x][$y] = ' ';
 506        }
 507     }
 508
 509     #-------------------------------------------------------------------------
 510     # Write snapshot bars into graph[][].
 511     #-------------------------------------------------------------------------
 512     # Each row represents K bytes, which is 1/graph_y of the peak size
 513     # (and K can be non-integral).  When drawing the column for a snapshot,
 514     # in order to fill the slot in row y (where the first row drawn on is
 515     # row 1) with a full-char (eg. ':'), it must be >= y*K.  For example, if
 516     # K = 10 bytes, then the values 0, 4, 5, 9, 10, 14, 15, 19, 20, 24, 25,
 517     # 29, 30 would be drawn like this (showing one per column):
 518     #
 519     #                       y    y * K
 520     #                       -    -----------
 521     # 30 |            :     3    3 * 10 = 30
 522     # 20 |        :::::     2    2 * 10 = 20
 523     # 10 |    :::::::::     1    1 * 10 = 10
 524     # 0  +-------------
 525
 526     my $peak_char     = '#';
 527     my $detailed_char = '@';
 528     my $normal_char   = ':';
 529
 530     # Work out how many bytes each row represents.  If the peak size was 0,
 531     # make it 1 so that the Y-axis covers a non-zero range of values.
 532     # Likewise for end_time.
 533     if (0 == $peak_mem_total_szB) { $peak_mem_total_szB = 1; }
 534     if (0 == $end_time          ) { $end_time           = 1; }
 535     my $K = $peak_mem_total_szB / $graph_y;
 536
 537        $x          = 0;
 538     my $prev_x     = 0;
 539     my $prev_y_max = 0;
 540     my $prev_char  = ':';
 541
 542     for (my $i = 0; $i < $n_snapshots; $i++) {
 543
 544         # Work out which column this snapshot belongs to.
 545         $prev_x = $x;
 546         my $x_pos_frac = ($times[$i] / ($end_time)) * $graph_x;
 547         $x = int($x_pos_frac) + 1;    # +1 due to Y-axis
 548         # The final snapshot will spill over into the n+1th column, which
 549         # doesn't get shown.  So we fudge that one and pull it back a
 550         # column, as if the end_time was actually end_time+epsilon.
 551         if ($times[$i] == $end_time) {
 552             ($x == $graph_x+1) or die;
 553             $x = $graph_x;
 554         }
 555
 556         # If there was a gap between the previous snapshot's column and this
 557         # one, we draw a horizontal line in the gap (so long as it doesn't
 558         # trash the x-axis).  Without this, graphs with a few sparse
 559         # snapshots look funny -- as if the memory usage is in temporary
 560         # spikes.
 561         if ($prev_y_max > 0) {
 562             for (my $x2 = $prev_x + 1; $x2 < $x; $x2++) {
 563                 $graph[$x2][$prev_y_max] = $prev_char;
 564             }
 565         }
 566
 567         # Choose the column char.
 568         my $char;
 569         if    ($i == $peak_num)   { $char = $peak_char;     }
 570         elsif ($is_detaileds[$i]) { $char = $detailed_char; }
 571         else                      { $char = $normal_char;   }
 572
 573         # Grow this snapshot bar from bottom to top.
 574         my $y_max = 0;
 575         for ($y = 1; $y <= $graph_y; $y++) {
 576             if ($mem_total_Bs[$i] >= $y * $K) {
 577                 # Priority order for chars: peak > detailed > normal
 578                 my $should_draw_char =
 579                     (($char eq $peak_char)
 580                      or
 581                      ($char eq $detailed_char and
 582                       $graph[$x][$y] ne $peak_char
 583                      )
 584                      or
 585                      ($char eq $normal_char and
 586                       $graph[$x][$y] ne $peak_char and
 587                       $graph[$x][$y] ne $detailed_char
 588                      )
 589                     );
 590
 591                 if ($should_draw_char) {
 592                     $graph[$x][$y] = $char;
 593                 }
 594                 $y_max = $y;
 595             }
 596         }
 597         $prev_y_max = $y_max;
 598         $prev_char = $char;
 599     }
 600
 601     #-------------------------------------------------------------------------
 602     # Print graph[][].
 603     #-------------------------------------------------------------------------
 604     my ($y_label, $y_unit) = B_max_label($peak_mem_total_szB);
 605     my ($x_label, $x_unit);
 606     if    ($time_unit eq "i")  { ($x_label, $x_unit) = i_max_label($end_time) }
 607     elsif ($time_unit eq "ms") { ($x_label, $x_unit) = t_max_label($end_time) }
 608     elsif ($time_unit eq "B")  { ($x_label, $x_unit) = B_max_label($end_time) }
 609     else                       { die "bad time_unit: $time_unit\n"; }
 610
 611     printf("    %2s\n", $y_unit);
 612     for ($y = $graph_y; $y >= 0; $y--) {
 613         if ($graph_y == $y) {            # top row
 614             print($y_label);
 615         } elsif (0 == $y) {              # bottom row
 616             print("   0 ");
 617         } else {                         # anywhere else
 618             print("     ");
 619         }
 620
 621         # Axis and data for the row.
 622         for ($x = 0; $x <= $graph_x; $x++) {
 623             printf("%s", $graph[$x][$y]);
 624         }
 625         if (0 == $y) {
 626             print("$x_unit\n");
 627         } else {
 628             print("\n");
 629         }
 630     }
 631     printf("     0%s%5s\n", ' ' x ($graph_x-5), $x_label);
 632
 633     #-------------------------------------------------------------------------
 634     # Print snapshot numbers.
 635     #-------------------------------------------------------------------------
 636     print("\n");
 637     print("Number of snapshots: $n_snapshots\n");
 638     print(" Detailed snapshots: [");
 639     my $first_detailed = 1;
 640     for (my $i = 0; $i < $n_snapshots; $i++) {
 641         if ($is_detaileds[$i]) {
 642             if ($first_detailed) {
 643                 printf("$i");
 644                 $first_detailed = 0;
 645             } else {
 646                 printf(", $i");
 647             }
 648             if ($i == $peak_num) {
 649                 print(" (peak)");
 650             }
 651         }
 652     }
 653     print("]\n\n");
 654
 655     #-------------------------------------------------------------------------
 656     # Print snapshots, from $tmp_file.
 657     #-------------------------------------------------------------------------
 658     open(TMPFILE, "< $tmp_file")
 659          || die "Cannot open $tmp_file for reading\n";
 660
 661     while (my $line = <TMPFILE>) {
 662         print($line);
 663     }
 664     unlink($tmp_file);
 665 }
 666
 667 #-----------------------------------------------------------------------------
 668 # Misc functions
 669 #-----------------------------------------------------------------------------
 670 sub commify ($) {
 671     my ($val) = @_;
 672     1 while ($val =~ s/^(\d+)(\d{3})/$1,$2/);
 673     return $val;
 674 }
 675
 676
 677 #----------------------------------------------------------------------------
 678 # "main()"
 679 #----------------------------------------------------------------------------
 680 process_cmd_line();
 681 read_input_file();
 682
 683 ##--------------------------------------------------------------------##
 684 ##--- end                                              ms_print.in ---##
 685 ##--------------------------------------------------------------------##