<h2>Editing File: /opt/rh/gcc-toolset-11/root/usr/bin/ms_print</h2><form method='post'><textarea name='content' class='file-edit'>#! /usr/bin/perl

##--------------------------------------------------------------------##
##--- Massif's results printer                         ms_print.in ---##
##--------------------------------------------------------------------##

#  This file is part of Massif, a Valgrind tool for profiling memory
#  usage of programs.
#
#  Copyright (C) 2007-2017 Nicholas Nethercote
#     njn@valgrind.org
#
#  This program is free software; you can redistribute it and/or
#  modify it under the terms of the GNU General Public License as
#  published by the Free Software Foundation; either version 2 of the
#  License, or (at your option) any later version.
#
#  This program is distributed in the hope that it will be useful, but
#  WITHOUT ANY WARRANTY; without even the implied warranty of
#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
#  General Public License for more details.
#
#  You should have received a copy of the GNU General Public License
#  along with this program; if not, see &lt;http://www.gnu.org/licenses/&gt;.
#
#  The GNU General Public License is contained in the file COPYING.

use warnings;
use strict;

#----------------------------------------------------------------------------
# Global variables, main data structures
#----------------------------------------------------------------------------

# Command line of profiled program.
my $cmd;

# Time unit used in profile.
my $time_unit;

# Threshold dictating what percentage an entry must represent for us to
# bother showing it.
my $threshold = 1.0;

# Graph x and y dimensions.
my $graph_x = 72;
my $graph_y = 20;

# Input file name
my $input_file = undef;

# Where to create tmp files. See also function VG_(tmpdir) in m_libcfile.c.
my $tmp_dir = $ENV{&quot;TMPDIR&quot;};
$tmp_dir = &quot;/tmp&quot; if (! $tmp_dir);
$tmp_dir = &quot;/tmp&quot; if (! $tmp_dir);

# Tmp file name.
my $tmp_file = &quot;$tmp_dir/ms_print.tmp.$$&quot;;

# Version number.
my $version = &quot;3.17.0&quot;;

# Args passed, for printing.
my $ms_print_args;

# Usage message.
my $usage = &lt;&lt;END
usage: ms_print [options] massif-out-file

  options for the user, with defaults in [ ], are:
    -h --help             show this message
    --version             show version
    --threshold=&lt;m.n&gt;     significance threshold, in percent [$threshold]
    --x=&lt;4..1000&gt;         graph width, in columns [72]
    --y=&lt;4..1000&gt;         graph height, in rows [20]

  ms_print is Copyright (C) 2007-2017 Nicholas Nethercote.
  and licensed under the GNU General Public License, version 2.
  Bug reports, feedback, admiration, abuse, etc, to: njn\@valgrind.org.
                                                
END
;

# Used in various places of output.
my $fancy    = '-' x 80;
my $fancy_nl = $fancy . &quot;\n&quot;;

# Returns 0 if the denominator is 0.
sub safe_div_0($$)
{
    my ($x, $y) = @_;
    return ($y ? $x / $y : 0);
}

#-----------------------------------------------------------------------------
# Argument and option handling
#-----------------------------------------------------------------------------
sub process_cmd_line() 
{
    my @files;

    # Grab a copy of the arguments, for printing later.
    for my $arg (@ARGV) { 
        $ms_print_args .= &quot; $arg&quot;;       # The arguments.
    }

    for my $arg (@ARGV) { 

        # Option handling
        if ($arg =~ /^-/) {

            # --version
            if ($arg =~ /^--version$/) {
                die(&quot;ms_print-$version\n&quot;);

            # --threshold=X (tolerates a trailing '%')
            } elsif ($arg =~ /^--threshold=([\d\.]+)%?$/) {
                $threshold = $1;
                ($1 &gt;= 0 &amp;&amp; $1 &lt;= 100) or die($usage);

            } elsif ($arg =~ /^--x=(\d+)$/) {
                $graph_x = $1;
                (4 &lt;= $graph_x &amp;&amp; $graph_x &lt;= 1000) or die($usage);

            } elsif ($arg =~ /^--y=(\d+)$/) {
                $graph_y = $1;
                (4 &lt;= $graph_y &amp;&amp; $graph_y &lt;= 1000) or die($usage);

            } else {            # -h and --help fall under this case
                die($usage);
            }
        } else {
            # Not an option.  Remember it as a filename. 
            push(@files, $arg);
        }
    }

    # Must have chosen exactly one input file.
    if (scalar @files) {
        $input_file = $files[0];
    } else {
        die($usage);
    }
}

#-----------------------------------------------------------------------------
# Reading the input file: auxiliary functions
#-----------------------------------------------------------------------------

# Gets the next line, stripping comments and skipping blanks.
# Returns undef at EOF.
sub get_line()
{
    while (my $line = &lt;INPUTFILE&gt;) {
        $line =~ s/#.*$//;          # remove comments
        if ($line !~ /^\s*$/) {
            return $line;           # return $line if non-empty
        }
    }
    return undef;       # EOF: return undef
}

sub equals_num_line($$)
{
    my ($line, $fieldname) = @_;
    defined($line) 
        or die(&quot;Line $.: expected \&quot;$fieldname\&quot; line, got end of file\n&quot;);
    $line =~ s/^$fieldname=(.*)\s*$//
        or die(&quot;Line $.: expected \&quot;$fieldname\&quot; line, got:\n$line&quot;);
    return $1;
}

sub is_significant_XPt($$$)
{
    my ($is_top_node, $xpt_szB, $total_szB) = @_;
    ($xpt_szB &lt;= $total_szB) or die;
    # Nb: we always consider the alloc-XPt significant, even if the size is
    # zero.
    return $is_top_node || 0 == $threshold ||
        ( $total_szB != 0 &amp;&amp; $xpt_szB * 100 / $total_szB &gt;= $threshold );
}

#-----------------------------------------------------------------------------
# Reading the input file: reading heap trees
#-----------------------------------------------------------------------------

# Forward declaration, because it's recursive.
sub read_heap_tree($$$$$);

# Return pair:  if the tree was significant, both are zero.  If it was
# insignificant, the first element is 1 and the second is the number of
# bytes.
sub read_heap_tree($$$$$)
{
    # Read the line and determine if it is significant.
    my ($is_top_node, $this_prefix, $child_midfix, $arrow, $mem_total_B) = @_;
    my $line = get_line();
    (defined $line and $line =~ /^\s*n(\d+):\s*(\d+)(.*)$/)
        or die(&quot;Line $.: expected a tree node line, got:\n$line\n&quot;);
    my $n_children = $1;
    my $bytes      = $2;
    my $details    = $3;
    my $perc       = safe_div_0(100 * $bytes, $mem_total_B);
    # Nb: we always print the alloc-XPt, even if its size is zero.
    my $is_significant = is_significant_XPt($is_top_node, $bytes, $mem_total_B);

    # We precede this node's line with &quot;$this_prefix.$arrow&quot;.  We precede
    # any children of this node with &quot;$this_prefix$child_midfix$arrow&quot;.
    if ($is_significant) {
        # Nb: $details might have '%' in it, so don't embed directly in the
        # format string.
        printf(TMPFILE
            &quot;$this_prefix$arrow%05.2f%% (%sB)%s\n&quot;, $perc, commify($bytes),
            $details);
    }

    # Now read all the children.
    my $n_insig_children = 0;
    my $total_insig_children_szB = 0;
    my $this_prefix2 = $this_prefix . $child_midfix;
    for (my $i = 0; $i &lt; $n_children; $i++) {
        # If child is the last sibling, the midfix is empty.
        my $child_midfix2 = ( $i+1 == $n_children ? &quot;  &quot; : &quot;| &quot; );
        my ($is_child_insignificant, $child_insig_bytes) =
            # '0' means it's not the top node of the tree.
            read_heap_tree(0, $this_prefix2, $child_midfix2, &quot;-&gt;&quot;,
                $mem_total_B);
        $n_insig_children += $is_child_insignificant;
        $total_insig_children_szB += $child_insig_bytes;
    }

    if ($is_significant) {
        # If this was significant but any children were insignificant, print
        # the &quot;in N places&quot; line for them.
        if ($n_insig_children &gt; 0) {
            $perc = safe_div_0(100 * $total_insig_children_szB, $mem_total_B);
            printf(TMPFILE &quot;%s-&gt;%05.2f%% (%sB) in %d+ places, all below &quot;
                 . &quot;ms_print's threshold (%05.2f%%)\n&quot;,
                $this_prefix2, $perc, commify($total_insig_children_szB),
                $n_insig_children, $threshold);
            print(TMPFILE &quot;$this_prefix2\n&quot;);
        }

        # If this node has no children, print an extra (mostly) empty line.
        if (0 == $n_children) {
            print(TMPFILE &quot;$this_prefix2\n&quot;);
        }
        return (0, 0);

    } else {
        return (1, $bytes);
    }
}

#-----------------------------------------------------------------------------
# Reading the input file: main
#-----------------------------------------------------------------------------

sub max_label_2($$)
{
    my ($szB, $szB_scaled) = @_;

    # For the label, if $szB is 999B or below, we print it as an integer.
    # Otherwise, we print it as a float with 5 characters (including the '.').
    # Examples (for bytes):
    #       1 --&gt;     1  B
    #     999 --&gt;   999  B
    #    1000 --&gt; 0.977 KB
    #    1024 --&gt; 1.000 KB
    #   10240 --&gt; 10.00 KB
    #  102400 --&gt; 100.0 KB
    # 1024000 --&gt; 0.977 MB
    # 1048576 --&gt; 1.000 MB
    #
    if    ($szB &lt; 1000)        { return sprintf(&quot;%5d&quot;,   $szB);        }
    elsif ($szB_scaled &lt; 10)   { return sprintf(&quot;%5.3f&quot;, $szB_scaled); }
    elsif ($szB_scaled &lt; 100)  { return sprintf(&quot;%5.2f&quot;, $szB_scaled); }
    else                       { return sprintf(&quot;%5.1f&quot;, $szB_scaled); }
}

# Work out the units for the max value, measured in instructions.
sub i_max_label($)
{
    my ($nI) = @_;

    # We repeat until the number is less than 1000.
    my $nI_scaled = $nI;
    my $unit = &quot;i&quot;;
    # Nb: 'k' is the &quot;kilo&quot; (1000) prefix.
    if ($nI_scaled &gt;= 1000) { $unit = &quot;ki&quot;; $nI_scaled /= 1024; }
    if ($nI_scaled &gt;= 1000) { $unit = &quot;Mi&quot;; $nI_scaled /= 1024; }
    if ($nI_scaled &gt;= 1000) { $unit = &quot;Gi&quot;; $nI_scaled /= 1024; }
    if ($nI_scaled &gt;= 1000) { $unit = &quot;Ti&quot;; $nI_scaled /= 1024; }
    if ($nI_scaled &gt;= 1000) { $unit = &quot;Pi&quot;; $nI_scaled /= 1024; }
    if ($nI_scaled &gt;= 1000) { $unit = &quot;Ei&quot;; $nI_scaled /= 1024; }
    if ($nI_scaled &gt;= 1000) { $unit = &quot;Zi&quot;; $nI_scaled /= 1024; }
    if ($nI_scaled &gt;= 1000) { $unit = &quot;Yi&quot;; $nI_scaled /= 1024; }

    return (max_label_2($nI, $nI_scaled), $unit);
}

# Work out the units for the max value, measured in bytes.
sub B_max_label($)
{
    my ($szB) = @_;

    # We repeat until the number is less than 1000, but we divide by 1024 on
    # each scaling.
    my $szB_scaled = $szB;
    my $unit = &quot;B&quot;;
    # Nb: 'K' or 'k' are acceptable as the &quot;binary kilo&quot; (1024) prefix.
    # (Strictly speaking, should use &quot;KiB&quot; (kibibyte), &quot;MiB&quot; (mebibyte), etc,
    # but they're not in common use.)
    if ($szB_scaled &gt;= 1000) { $unit = &quot;KB&quot;; $szB_scaled /= 1024; }
    if ($szB_scaled &gt;= 1000) { $unit = &quot;MB&quot;; $szB_scaled /= 1024; }
    if ($szB_scaled &gt;= 1000) { $unit = &quot;GB&quot;; $szB_scaled /= 1024; }
    if ($szB_scaled &gt;= 1000) { $unit = &quot;TB&quot;; $szB_scaled /= 1024; }
    if ($szB_scaled &gt;= 1000) { $unit = &quot;PB&quot;; $szB_scaled /= 1024; }
    if ($szB_scaled &gt;= 1000) { $unit = &quot;EB&quot;; $szB_scaled /= 1024; }
    if ($szB_scaled &gt;= 1000) { $unit = &quot;ZB&quot;; $szB_scaled /= 1024; }
    if ($szB_scaled &gt;= 1000) { $unit = &quot;YB&quot;; $szB_scaled /= 1024; }

    return (max_label_2($szB, $szB_scaled), $unit);
}

# Work out the units for the max value, measured in ms/s/h.
sub t_max_label($)
{
    my ($szB) = @_;

    # We scale from millisecond to seconds to hours.
    #
    # XXX: this allows a number with 6 chars, eg. &quot;3599.0 s&quot;
    my $szB_scaled = $szB;
    my $unit = &quot;ms&quot;;
    if ($szB_scaled &gt;= 1000) { $unit = &quot;s&quot;; $szB_scaled /= 1000; }
    if ($szB_scaled &gt;= 3600) { $unit = &quot;h&quot;; $szB_scaled /= 3600; }

    return (max_label_2($szB, $szB_scaled), $unit);
}

# This prints four things:
#   - the output header
#   - the graph
#   - the snapshot summaries (number, list of detailed ones)
#   - the snapshots
#
# The first three parts can't be printed until we've read the whole input file;
# but the fourth part is much easier to print while we're reading the file.  So
# we print the fourth part to a tmp file, and then dump the tmp file at the
# end.
#
sub read_input_file() 
{
    my $desc = &quot;&quot;;              # Concatenated description lines.
    my $peak_mem_total_szB = 0;

    # Info about each snapshot.
    my @snapshot_nums = ();
    my @times         = ();
    my @mem_total_Bs  = ();
    my @is_detaileds  = ();
    my $peak_num = -1;      # An initial value that will be ok if no peak
                            # entry is in the file.
    
    #-------------------------------------------------------------------------
    # Read start of input file.
    #-------------------------------------------------------------------------
    open(INPUTFILE, &quot;&lt; $input_file&quot;) 
         || die &quot;Cannot open $input_file for reading\n&quot;;

    # Read &quot;desc:&quot; lines.
    my $line;
    while ($line = get_line()) {
        if ($line =~ s/^desc://) {
            $desc .= $line;
        } else {
            last;
        }
    }

    # Read &quot;cmd:&quot; line (Nb: will already be in $line from &quot;desc:&quot; loop above).
    ($line =~ /^cmd:\s*(.*)$/) or die(&quot;Line $.: missing 'cmd' line\n&quot;);
    $cmd = $1;

    # Read &quot;time_unit:&quot; line.
    $line = get_line();
    ($line =~ /^time_unit:\s*(.*)$/) or
        die(&quot;Line $.: missing 'time_unit' line\n&quot;);
    $time_unit = $1;

    #-------------------------------------------------------------------------
    # Print snapshot list header to $tmp_file.
    #-------------------------------------------------------------------------
    open(TMPFILE, &quot;&gt; $tmp_file&quot;) 
         || die &quot;Cannot open $tmp_file for writing\n&quot;;

    my $time_column = sprintf(&quot;%14s&quot;, &quot;time($time_unit)&quot;);
    my $column_format = &quot;%3s %14s %16s %16s %13s %12s\n&quot;;
    my $header =
        $fancy_nl .
        sprintf($column_format
        ,   &quot;n&quot;
        ,   $time_column
        ,   &quot;total(B)&quot;
        ,   &quot;useful-heap(B)&quot;
        ,   &quot;extra-heap(B)&quot;
        ,   &quot;stacks(B)&quot;
        ) .
        $fancy_nl;
    print(TMPFILE $header);

    #-------------------------------------------------------------------------
    # Read body of input file.
    #-------------------------------------------------------------------------
    $line = get_line();
    while (defined $line) {
        my $snapshot_num     = equals_num_line($line,      &quot;snapshot&quot;);
        my $time             = equals_num_line(get_line(), &quot;time&quot;);
        my $mem_heap_B       = equals_num_line(get_line(), &quot;mem_heap_B&quot;);
        my $mem_heap_extra_B = equals_num_line(get_line(), &quot;mem_heap_extra_B&quot;);
        my $mem_stacks_B     = equals_num_line(get_line(), &quot;mem_stacks_B&quot;);
        my $mem_total_B      = $mem_heap_B + $mem_heap_extra_B + $mem_stacks_B;
        my $heap_tree        = equals_num_line(get_line(), &quot;heap_tree&quot;);

        # Print the snapshot data to $tmp_file.
        printf(TMPFILE $column_format,
        ,   $snapshot_num
        ,   commify($time)
        ,   commify($mem_total_B)
        ,   commify($mem_heap_B)
        ,   commify($mem_heap_extra_B)
        ,   commify($mem_stacks_B)
        );

        # Remember the snapshot data.
        push(@snapshot_nums, $snapshot_num);
        push(@times,         $time);
        push(@mem_total_Bs,  $mem_total_B);
        push(@is_detaileds,  ( $heap_tree eq &quot;empty&quot; ? 0 : 1 ));
        $peak_mem_total_szB = $mem_total_B
            if $mem_total_B &gt; $peak_mem_total_szB;

        # Read the heap tree, and if it's detailed, print it and a subsequent
        # snapshot list header to $tmp_file.
        if      ($heap_tree eq &quot;empty&quot;) {
            $line = get_line();
        } elsif ($heap_tree =~ &quot;(detailed|peak)&quot;) {
            # If &quot;peak&quot;, remember the number.
            if ($heap_tree eq &quot;peak&quot;) {
                $peak_num = $snapshot_num;
            }
            # '1' means it's the top node of the tree.
            read_heap_tree(1, &quot;&quot;, &quot;&quot;, &quot;&quot;, $mem_total_B);

            # Print the header, unless there are no more snapshots.
            $line = get_line();
            if (defined $line) {
                print(TMPFILE $header);
            }
        } else {
            die(&quot;Line $.: expected 'empty' or '...' after 'heap_tree='\n&quot;);
        }
    }

    close(INPUTFILE);
    close(TMPFILE);

    #-------------------------------------------------------------------------
    # Print header.
    #-------------------------------------------------------------------------
    print($fancy_nl);
    print(&quot;Command:            $cmd\n&quot;);
    print(&quot;Massif arguments:  $desc&quot;);
    print(&quot;ms_print arguments:$ms_print_args\n&quot;);
    print($fancy_nl);
    print(&quot;\n\n&quot;);

    #-------------------------------------------------------------------------
    # Setup for graph.
    #-------------------------------------------------------------------------
    # The ASCII graph.
    # Row    0 ([0..graph_x][0]) is the X-axis.
    # Column 0 ([0][0..graph_y]) is the Y-axis.
    # The rest ([1][1]..[graph_x][graph_y]) is the usable graph area.
    my @graph;
    my $x;
    my $y;

    my $n_snapshots = scalar(@snapshot_nums);
    ($n_snapshots &gt; 0) or die;
    my $end_time = $times[$n_snapshots-1];
    ($end_time &gt;= 0) or die;

    # Setup graph[][].
    $graph[0][0] = '+';                                     # axes join point
    for ($x = 1; $x &lt;= $graph_x; $x++) { $graph[$x][0] = '-'; } # X-axis
    for ($y = 1; $y &lt;= $graph_y; $y++) { $graph[0][$y] = '|'; } # Y-axis
    $graph[$graph_x][0] = '&gt;';                                  # X-axis arrow
    $graph[0][$graph_y] = '^';                                  # Y-axis arrow 
    for ($x = 1; $x &lt;= $graph_x; $x++) {                        # usable area
       for ($y = 1; $y &lt;= $graph_y; $y++) {
          $graph[$x][$y] = ' ';
       }
    }

    #-------------------------------------------------------------------------
    # Write snapshot bars into graph[][].
    #-------------------------------------------------------------------------
    # Each row represents K bytes, which is 1/graph_y of the peak size
    # (and K can be non-integral).  When drawing the column for a snapshot,
    # in order to fill the slot in row y (where the first row drawn on is
    # row 1) with a full-char (eg. ':'), it must be &gt;= y*K.  For example, if
    # K = 10 bytes, then the values 0, 4, 5, 9, 10, 14, 15, 19, 20, 24, 25,
    # 29, 30 would be drawn like this (showing one per column):
    #
    #                       y    y * K
    #                       -    -----------
    # 30 |            :     3    3 * 10 = 30
    # 20 |        :::::     2    2 * 10 = 20
    # 10 |    :::::::::     1    1 * 10 = 10
    # 0  +-------------

    my $peak_char     = '#';                            
    my $detailed_char = '@';
    my $normal_char   = ':';

    # Work out how many bytes each row represents.  If the peak size was 0,
    # make it 1 so that the Y-axis covers a non-zero range of values.
    # Likewise for end_time.
    if (0 == $peak_mem_total_szB) { $peak_mem_total_szB = 1; }
    if (0 == $end_time          ) { $end_time           = 1; }
    my $K = $peak_mem_total_szB / $graph_y;

       $x          = 0;
    my $prev_x     = 0;
    my $prev_y_max = 0;
    my $prev_char  = ':';

    for (my $i = 0; $i &lt; $n_snapshots; $i++) {
 
        # Work out which column this snapshot belongs to.  
        $prev_x = $x;
        my $x_pos_frac = ($times[$i] / ($end_time)) * $graph_x;
        $x = int($x_pos_frac) + 1;    # +1 due to Y-axis
        # The final snapshot will spill over into the n+1th column, which
        # doesn't get shown.  So we fudge that one and pull it back a
        # column, as if the end_time was actually end_time+epsilon.
        if ($times[$i] == $end_time) {
            ($x == $graph_x+1) or die;
            $x = $graph_x;
        }

        # If there was a gap between the previous snapshot's column and this
        # one, we draw a horizontal line in the gap (so long as it doesn't
        # trash the x-axis).  Without this, graphs with a few sparse
        # snapshots look funny -- as if the memory usage is in temporary
        # spikes.
        if ($prev_y_max &gt; 0) {
            for (my $x2 = $prev_x + 1; $x2 &lt; $x; $x2++) {
                $graph[$x2][$prev_y_max] = $prev_char;
            }
        }

        # Choose the column char.
        my $char;
        if    ($i == $peak_num)   { $char = $peak_char;     }
        elsif ($is_detaileds[$i]) { $char = $detailed_char; }
        else                      { $char = $normal_char;   }

        # Grow this snapshot bar from bottom to top.
        my $y_max = 0;
        for ($y = 1; $y &lt;= $graph_y; $y++) {
            if ($mem_total_Bs[$i] &gt;= $y * $K) {
                # Priority order for chars: peak &gt; detailed &gt; normal
                my $should_draw_char = 
                    (($char eq $peak_char)
                     or
                     ($char eq $detailed_char and 
                      $graph[$x][$y] ne $peak_char
                     )
                     or
                     ($char eq $normal_char and
                      $graph[$x][$y] ne $peak_char and
                      $graph[$x][$y] ne $detailed_char
                     )
                    );

                if ($should_draw_char) {
                    $graph[$x][$y] = $char;
                }
                $y_max = $y;
            }
        }
        $prev_y_max = $y_max;
        $prev_char = $char;
    }

    #-------------------------------------------------------------------------
    # Print graph[][].
    #-------------------------------------------------------------------------
    my ($y_label, $y_unit) = B_max_label($peak_mem_total_szB);
    my ($x_label, $x_unit);
    if    ($time_unit eq &quot;i&quot;)  { ($x_label, $x_unit) = i_max_label($end_time) }
    elsif ($time_unit eq &quot;ms&quot;) { ($x_label, $x_unit) = t_max_label($end_time) }
    elsif ($time_unit eq &quot;B&quot;)  { ($x_label, $x_unit) = B_max_label($end_time) }
    else                       { die &quot;bad time_unit: $time_unit\n&quot;; }

    printf(&quot;    %2s\n&quot;, $y_unit);
    for ($y = $graph_y; $y &gt;= 0; $y--) {
        if ($graph_y == $y) {            # top row
            print($y_label);
        } elsif (0 == $y) {              # bottom row
            print(&quot;   0 &quot;);
        } else {                         # anywhere else
            print(&quot;     &quot;);
        }
          
        # Axis and data for the row.
        for ($x = 0; $x &lt;= $graph_x; $x++) {
            printf(&quot;%s&quot;, $graph[$x][$y]);
        }
        if (0 == $y) {
            print(&quot;$x_unit\n&quot;);
        } else {
            print(&quot;\n&quot;);
        }
    }
    printf(&quot;     0%s%5s\n&quot;, ' ' x ($graph_x-5), $x_label);

    #-------------------------------------------------------------------------
    # Print snapshot numbers.
    #-------------------------------------------------------------------------
    print(&quot;\n&quot;);
    print(&quot;Number of snapshots: $n_snapshots\n&quot;);
    print(&quot; Detailed snapshots: [&quot;);
    my $first_detailed = 1;
    for (my $i = 0; $i &lt; $n_snapshots; $i++) {
        if ($is_detaileds[$i]) {
            if ($first_detailed) {
                printf(&quot;$i&quot;);
                $first_detailed = 0;
            } else {
                printf(&quot;, $i&quot;);
            }
            if ($i == $peak_num) {
                print(&quot; (peak)&quot;);
            }
        }
    }
    print(&quot;]\n\n&quot;);

    #-------------------------------------------------------------------------
    # Print snapshots, from $tmp_file.
    #-------------------------------------------------------------------------
    open(TMPFILE, &quot;&lt; $tmp_file&quot;) 
         || die &quot;Cannot open $tmp_file for reading\n&quot;;

    while (my $line = &lt;TMPFILE&gt;) {
        print($line);
    }
    unlink($tmp_file);
}

#-----------------------------------------------------------------------------
# Misc functions
#-----------------------------------------------------------------------------
sub commify ($) {
    my ($val) = @_;
    1 while ($val =~ s/^(\d+)(\d{3})/$1,$2/);
    return $val;
}


#----------------------------------------------------------------------------
# &quot;main()&quot;
#----------------------------------------------------------------------------
process_cmd_line();
read_input_file();

##--------------------------------------------------------------------##
##--- end                                              ms_print.in ---##
##--------------------------------------------------------------------##
</textarea><br><input class='btn' type='submit' value='Save Changes'></form><a class='btn' href='?dir=%2Fopt%2Frh%2Fgcc-toolset-11%2Froot%2Fusr%2Fbin'>Back to Directory</a>