Fix parsing of maximum residency in runstdtest
[nofib.git] / runstdtest / runstdtest.prl
1 #
2 # The perl script requires the following variables to be bound
3 # to something meaningful before it will operate correctly:
4 #   
5 #   CONTEXT_DIFF
6 #   RM
7 #
8 # Given:
9 #       * a program to run (1st arg)
10 #       * some "command-line opts" ( -O<opt1> -O<opt2> ... )
11 #           [default: anything on the cmd line this script doesn't recognise ]
12 #         the first opt not starting w/ "-" is taken to be an input
13 #         file and (if it exists) is grepped for "what's going on here"
14 #         comments (^-- !!!).
15 #       * a file to feed to stdin ( -i<file> ) [default: /dev/null ]
16 #       * a "time" command to use (-t <cmd>).
17 #
18 #       * alternatively, a "-script <script>" argument says: run the
19 #         named Bourne-shell script to do the test.  It's passed the
20 #         pgm-to-run as the one-and-only arg.
21 #
22 # Run the program with those options and that input, and check:
23 # if we get...
24
25 #       * an expected exit status ( -x <val> ) [ default 0 ]
26 #       * expected output on stdout ( -o1 <file> ) [ default /dev/null ]
27 #               ( we'll accept one of several...)
28 #       * expected output on stderr ( -o2 <file> ) [ default /dev/null ]
29 #               ( we'll accept one of several...)
30 #
31 #       (if the expected-output files' names end in .Z, then
32 #        they are uncompressed before doing the comparison)
33
34 # (This is supposed to be a "prettier" replacement for runstdtest.)
35 #
36 #       Flags
37 #       ~~~~~
38 #       -accept-output  replace output files with the ones actually generated by running
39 #                       the program
40 #
41 ($Pgm = $0) =~ s|.*/||;
42 $Verbose = 0;
43 $SaveStderr = 0;
44 $SaveStdout = 0;
45 $StdoutBinary = 0;
46 $StderrBinary = 0;
47 $Status = 0;
48 @PgmArgs = ();
49 $PgmFail=0;
50 $PgmExitStatus = 0;
51 $PgmStdinFile  = '/dev/null';
52 if ( $ENV{'TMPDIR'} ) { # where to make tmp file names
53     $TmpPrefix = $ENV{'TMPDIR'};
54 } else {
55     $TmpPrefix = '/tmp';
56     $ENV{'TMPDIR'} = '/tmp'; # set the env var as well
57 }
58 # If this is Msys, ignore eol and CR characters.
59 if ( `uname -s | grep MSYS` ) {
60     $CONTEXT_DIFF=$CONTEXT_DIFF . " --strip-trailing-cr" ;
61 }
62 $ScriptFile = "$TmpPrefix/run_me$$";
63 $DefaultStdoutFile = "$TmpPrefix/no_stdout$$"; # can't use /dev/null (e.g. Alphas)
64 $DefaultStderrFile = "$TmpPrefix/no_stderr$$";
65 @PgmStdoutFile = ();
66 @PgmStderrFile = ();
67 $PreScript = '';
68 $PostScript = '';
69 $TimeCmd = 'time';
70 $StatsFile = "$TmpPrefix/stats$$";
71 $CachegrindStats = "cachegrind.out.summary";
72 $SysSpecificTiming = '';
73 $SysCPUCounting = 0; # Use CPU counters
74 $Cachegrind = 'no';
75 $Counters = "";
76
77 die "$Pgm: program to run not given as first argument\n" if $#ARGV < 0;
78 $ToRun = $ARGV[0]; shift(@ARGV);
79 # avoid picking up same-named thing from somewhere else on $PATH...
80 $ToRun = "./$ToRun" if -e "./$ToRun";
81
82 $procs = 1; # unless we pick up a -N flag in the arguments
83
84 arg: while ($_ = $ARGV[0]) {
85     shift(@ARGV);
86     
87     /^--$/      && do { # let anything past after --
88                         push(@PgmArgs, @ARGV);
89                         last arg; };
90
91     /^-v$/             && do { $Verbose = 1; next arg; };
92     /^-accept-output-stderr$/ && do { $SaveStderr = 1; next arg; };
93     /^-accept-output-stdout$/ && do { $SaveStdout = 1; next arg; };
94     /^-accept-output$/        && do { $SaveStdout = 1; $SaveStderr = 1; next arg; };
95
96     /^-stdout-binary/ && do { $StdoutBinary=1; next arg; };
97     /^-stderr-binary/ && do { $StderrBinary=1; next arg; };
98
99     /^-O(.*)/   && do { push(@PgmArgs, &grab_arg_arg('-O',$1)); next arg; };
100     /^-i(.*)/   && do { $PgmStdinFile = &grab_arg_arg('-i',$1);
101                         $Status++,
102                         print STDERR "$Pgm: bogus -i input file: $PgmStdinFile\n"
103                             if $PgmStdinFile !~ /^\/dev\/.*$/ && ! -f $PgmStdinFile;
104                         next arg; };
105     /^-fail/    && do { $PgmFail=1; next arg; };
106     /^-x(.*)/   && do { $PgmExitStatus = &grab_arg_arg('-x',$1);
107                         $Status++ ,
108                         print STDERR "$Pgm: bogus -x expected exit status: $PgmExitStatus\n"
109                             if $PgmExitStatus !~ /^\d+$/;
110                         next arg; };
111     /^-o1(.*)/  && do { $out_file = &grab_arg_arg('-o1',$1);
112                         push(@PgmStdoutFile, $out_file);
113                         next arg; };
114     /^-o2(.*)/  && do { $out_file = &grab_arg_arg('-o2',$1);
115                         push(@PgmStderrFile, $out_file);
116                         next arg; };
117     /^-prescript(.*)/  && do { $PreScript = &grab_arg_arg('-prescript',$1);
118                                 next arg; };
119     /^-postscript(.*)/ && do { $PostScript = &grab_arg_arg('-postscript',$1);
120                                 next arg; };
121     /^-script/ && do { print STDERR "$Pgm: -script argument is obsolete;\nUse -prescript and -postscript instead.\n";
122                     $Status++;
123                     next arg; };
124     /^-(ghc|hbc)-timing$/ && do { $SysSpecificTiming = $1;
125                                   next arg; };
126     /^-cpu-counting-(.)$/ && do { $SysCPUCounting = "$1";
127                                   next arg; };
128     /^-cachegrind$/ && do { $SysSpecificTiming = 'ghc-instrs';
129                             $Cachegrind = 'yes'; 
130                             next arg };
131     /^-t(.*)/   && do { $TimeCmd = &grab_arg_arg('-t', $1); next arg; };
132
133     /^-N(\d+)/  && do { $procs = $1; };
134
135     # anything else is taken to be a pgm arg
136     push(@PgmArgs, $_);
137 }
138
139 foreach $out_file ( @PgmStdoutFile ) {
140     if ( ! -f $out_file && !$SaveStdout ) {
141             print STDERR "$Pgm: warning: expected-stdout file missing: $out_file\n";
142             pop(@PgmStdoutFile);
143     }
144 }
145
146 foreach $out_file ( @PgmStderrFile ) {
147     if ( ! -f $out_file && !$SaveStderr ) {
148             print STDERR "$Pgm: warning: expected-stderr file missing: $out_file\n";
149             pop(@PgmStderrFile);
150     }
151 }
152
153 exit 1 if $Status;
154
155 # add on defaults if none specified
156 @PgmStdoutFile = ( $DefaultStdoutFile ) if $#PgmStdoutFile < 0;
157 @PgmStderrFile = ( $DefaultStderrFile ) if $#PgmStderrFile < 0;
158
159 # tidy up the pgm args:
160 # (1) look for the "first input file"
161 #     and grep it for "interesting" comments (-- !!! )
162 # (2) quote any args w/ whitespace in them.
163 $grep_done = 0;
164 foreach $a ( @PgmArgs ) {
165     if (! $grep_done && $a !~ /^-/ && -f $a) {
166         print `egrep "^--[ ]?!!!" $a`;
167         $grep_done = 1;
168     }
169     if ($a =~ /\s/ || $a =~ /'/) {
170         $a =~ s/'/\\'/g;    # backslash the quotes;
171         $a = "\"$a\"";      # quote the arg
172     }
173 }
174
175 # deal with system-specific timing options
176 $TimingMagic = '';
177 if ( $SysSpecificTiming =~ /^ghc/ ) {
178     if ($SysCPUCounting) {
179         # Count specified CPU events
180         $cpu_counting_ghc = "-a$SysCPUCounting";
181     } else {
182         $cpu_counting_ghc = "";
183     }
184     $TimingMagic = "+RTS -s$StatsFile $cpu_counting_ghc -RTS"
185 } elsif ( $SysSpecificTiming eq 'hbc' ) {
186     $TimingMagic = "-s$StatsFile";
187 }
188
189 if ($PreScript ne '') {
190     local($to_do);
191     $PreScriptLines = `cat $PreScript`;
192     $PreScriptLines =~ s/\r//g;
193 } else {
194     $PreScriptLines = '';
195 }
196
197 if ($PostScript ne '') {
198     local($to_do);
199     $PostScriptLines = `cat $PostScript`;
200     $PostScriptLines =~ s/\r//g;
201     $PostScriptLines =~ s#\$o1#$TmpPrefix/runtest$$.1#gm;
202     $PostScriptLines =~ s#\$o2#$TmpPrefix/runtest$$.2#gm;
203 # The postfix 'm' deals with recent versions of 
204 # Perl that removed the $* feature
205 } else {
206     $PostScriptLines = '';
207 }
208
209 # OK, so we're gonna do the normal thing...
210
211 if ($Cachegrind eq 'yes') {
212   $CachegrindPrefix = "valgrind --tool=cachegrind --log-fd=9 9>$CachegrindStats";
213 } else {
214   $CachegrindPrefix = '';
215 }
216
217 $Script = <<EOSCRIPT;
218 #! /bin/sh
219 myexit=0
220 diffsShown=0
221 rm -f $DefaultStdoutFile $DefaultStderrFile
222 cat /dev/null > $DefaultStdoutFile
223 cat /dev/null > $DefaultStderrFile
224 $PreScriptLines
225 $SpixifyLine1
226 # NB: if you plan to use "sed" in this script please bear in mind that in some seds (in particular BSD sed,
227 # also used on OS X) the output is always terminated by a new line, even if the input wasn't. This can cause
228 # spurious cmp failures if the expected stderr/stdout did not have a trailing newline.
229 #
230 # We try to use tr instead to avoid these problems. Make sure you run it in the C locale or else it may throw
231 # an error if the input string is not encoded in the locale encoding.
232 $TimeCmd /bin/sh -c \'$CachegrindPrefix $ToRun $TimingMagic @PgmArgs < $PgmStdinFile 1> $TmpPrefix/runtest$$.1.raw 2> $TmpPrefix/runtest$$.2.raw 3> $TmpPrefix/runtest$$.3.raw\'
233 progexit=\$?
234 if [ "$StdoutBinary" = "0" ]; then
235     # remove Windows \r carraige-returns
236     LC_CTYPE=C tr -d '\\r' < $TmpPrefix/runtest$$.1.raw > $TmpPrefix/runtest$$.1
237 else
238     cp $TmpPrefix/runtest$$.1.raw $TmpPrefix/runtest$$.1
239 fi
240 if [ "$StderrBinary" = "0" ]; then
241     # remove Windows \r carraige-returns
242     LC_CTYPE=C tr -d '\\r' < $TmpPrefix/runtest$$.2.raw > $TmpPrefix/runtest$$.2
243 else
244     cp $TmpPrefix/runtest$$.2.raw $TmpPrefix/runtest$$.2
245 fi
246 LC_CTYPE=C tr -d '\\r' < $TmpPrefix/runtest$$.3.raw > $TmpPrefix/runtest$$.3
247 if [ \$progexit -eq 0 ] && [ $PgmFail -ne 0 ]; then
248     echo $ToRun @PgmArgs \\< $PgmStdinFile
249     echo "****" expected a failure, but was successful
250     myexit=1
251 fi
252 if [ \$progexit -ne $PgmExitStatus ] && [ $PgmFail -eq 0 ]; then
253     echo $ToRun @PgmArgs \\< $PgmStdinFile
254     echo "****" expected exit status $PgmExitStatus not seen \\; got \$progexit
255     myexit=1
256 else
257     $PostScriptLines
258     hit='NO'
259     for out_file in @PgmStdoutFile ; do
260         if cmp -s \$out_file $TmpPrefix/runtest$$.1 ; then
261             hit='YES'
262         fi
263     done
264     if [ \$hit = 'NO' ] ; then
265         echo $ToRun @PgmArgs \\< $PgmStdinFile
266         echo expected stdout not matched by reality
267         orig_file="$PgmStdoutFile[0]";
268         [ ! -f \$orig_file ] && orig_file="/dev/null"
269         ${CONTEXT_DIFF} \$orig_file $TmpPrefix/runtest$$.1
270         myexit=\$?
271         diffsShown=1
272     fi
273     if [ $SaveStdout = 1 ] && 
274        [ $PgmStdoutFile[0] != $DefaultStdoutFile ] && [ -s $TmpPrefix/runtest$$.1 ]; then
275         echo Saving away stdout output in $PgmStdoutFile[0] ...
276         if [ -f $PgmStdoutFile[0] ]; then
277              rm -f $PgmStdoutFile[0].bak
278              cp $PgmStdoutFile[0] $PgmStdoutFile[0].bak
279         fi;
280         cp $TmpPrefix/runtest$$.1 $PgmStdoutFile[0]
281     fi
282 fi
283
284 hit='NO'
285 for out_file in @PgmStderrFile ; do
286     if cmp -s \$out_file $TmpPrefix/runtest$$.2 ; then
287         hit='YES'
288     fi
289 done
290 if [ \$hit = 'NO' ] ; then
291     echo $ToRun @PgmArgs \\< $PgmStdinFile
292     echo expected stderr not matched by reality
293     orig_file="$PgmStderrFile[0]"
294     [ ! -f \$orig_file ] && orig_file="/dev/null"
295     ${CONTEXT_DIFF} \$orig_file $TmpPrefix/runtest$$.2
296     myexit=\$?
297     diffsShown=1
298 fi
299 if [ $SaveStderr = 1 ] &&
300    [ $PgmStderrFile[0] != $DefaultStderrFile ] && [ -s $TmpPrefix/runtest$$.2 ]; then
301         echo Saving away stderr output in $PgmStderrFile[0] ...
302         if [ -f $PgmStderrFile[0] ]; then
303            rm -f $PgmStderrFile[0].bak
304            cp $PgmStderrFile[0] $PgmStderrFile[0].bak
305         fi;
306         cp $TmpPrefix/runtest$$.2 $PgmStderrFile[0]
307 fi
308
309 ${RM} core $ToRunOrig.spix $DefaultStdoutFile $DefaultStderrFile $TmpPrefix/runtest$$.1 $TmpPrefix/runtest$$.2 $TmpPrefix/runtest$$.3 $TmpPrefix/runtest$$.1.raw $TmpPrefix/runtest$$.2.raw $TmpPrefix/runtest$$.3.raw
310 exit \$myexit
311 EOSCRIPT
312
313 # bung script into a file
314 open(SCR, "> $ScriptFile") || die "Failed opening script file $ScriptFile!\n";
315 print SCR $Script;
316 close(SCR) || die "Failed closing script file!\n";
317 chmod 0755, $ScriptFile;
318
319 print STDERR $Script if $Verbose;
320
321 &run_something($ScriptFile);
322
323 if ( $SysSpecificTiming eq '' ) {
324     unlink $StatsFile;
325     unlink $ScriptFile;
326     exit 0;
327 }
328
329 &process_stats_file();
330 &process_cachegrind_files() if $Cachegrind eq 'yes';
331
332 # print out what we found
333 print STDERR "<<$SysSpecificTiming: ";
334 if ( $Cachegrind ne 'yes') {
335         print STDERR "$BytesAlloc bytes, $GCs GCs ($Gc0Count + $Gc1Count), $AvgResidency/$MaxResidency avg/max bytes residency ($ResidencySamples samples), $GCWork bytes GC work, ${TotMem}M in use, $InitTime INIT ($InitElapsed elapsed), $MutTime MUT ($MutElapsed elapsed), $GcTime GC ($GcElapsed elapsed), $Gc0Time GC(0) ($Gc0Elapsed elapsed), $Gc1Time GC(1) ($Gc1Elapsed elapsed), $Balance balance$Counters";
336 } else {
337         print STDERR "$BytesAlloc bytes, $GCs GCs ($Gc0Count + $Gc1Count), $AvgResidency/$MaxResidency avg/max bytes residency ($ResidencySamples samples), $GCWork bytes GC work, ${TotMem}M in use, $InitTime INIT ($InitElapsed elapsed), $MutTime MUT ($MutElapsed elapsed), $GcTime GC ($GcElapsed elapsed), $Gc0Time GC(0) ($Gc0Elapsed elapsed), $Gc1Time GC(1) ($Gc1Elapsed elapsed), $Balance balance, $TotInstrs instructions, $TotReads memory reads, $TotWrites memory writes, $TotMisses L2 cache misses";
338 };
339 print STDERR " :$SysSpecificTiming>>\n";
340
341 # OK, party over
342 unlink $StatsFile;
343 unlink $ScriptFile;
344 exit 0;
345
346 sub grab_arg_arg {
347     local($option, $rest_of_arg) = @_;
348     
349     if ($rest_of_arg ne "") {
350         return($rest_of_arg);
351     } elsif ($#ARGV >= 0) {
352         local($temp) = $ARGV[0]; shift(@ARGV); 
353         return($temp);
354     } else {
355         print STDERR "$Pgm: no argument following $option option\n";
356         $Status++;
357     }
358 }
359
360 sub run_something {
361     local($str_to_do) = @_;
362
363 #   print STDERR "$str_to_do\n" if $Verbose;
364
365     local($return_val) = 0;
366     system($str_to_do);
367     $return_val = $?;
368
369     if ($return_val != 0) {
370 #ToDo: this return-value mangling is wrong
371 #       local($die_msg) = "$Pgm: execution of the $tidy_name had trouble";
372 #       $die_msg .= " (program not found)" if $return_val == 255;
373 #       $die_msg .= " ($!)" if $Verbose && $! != 0;
374 #       $die_msg .= "\n";
375         unlink $ScriptFile;
376         unlink $StatsFile;
377
378         exit (($return_val == 0) ? 0 : 1);
379     }
380 }
381
382 sub process_stats_file {
383
384     # OK, process system-specific stats file
385     if ( $SysSpecificTiming =~ /^ghc/ ) {
386
387         #NB: nearly the same as in GHC driver's -ghc-timing stuff
388
389         open(STATS, $StatsFile) || die "Failed when opening $StatsFile\n";
390
391         local($max_live)    = 0; 
392         local($tot_live)    = 0; # for calculating residency stuff
393         local($tot_samples) = 0;
394         local($into_gc_counters) = 0; # once we reach into the GC counters part
395         local($counters) = "";
396         local($counter) = "";
397         local($count) = 0;
398
399         $GCWork = 0;
400         $GCs = 0;
401         $Balance = 1;
402         while (<STATS>) {
403             if (! /Gen:\s+0/ && /^\s*\d+\s+\d+\s+(\d+)\s+\d+\.\d+/ ) {
404                 # This is only hit for -S and will override the residency
405                 # numbers from -s if found.
406                 # -S is needed for average residency numbers, which is 0
407                 # otherwise.
408                 $max_live = $1 if $max_live < $1;
409                 $tot_live += $1;
410                 $tot_samples += 1;
411             }
412
413             $BytesAlloc = $1 if /^\s*([0-9,]+) bytes allocated in the heap/;
414             
415             if (/^\s*([0-9,]+) bytes (copied during GC|globalised)/) {
416                $tmp = $1;
417                $tmp =~ s/,//g;
418                $GCWork += $tmp;
419             }
420
421             if ( /^\s*([0-9,]+) bytes maximum residency.*(\d+) sample/ ) {
422                 $MaxResidency = $1;
423                 $ResidencySamples = $2;
424             }
425
426             if ( /^\s+([0-9]+)\s+M[Bb] total memory/ ) {
427                 $TotMem = $1;
428             }
429
430             if ( /^\s*INIT\s+time\s*(-*\d+\.\d\d+)s\s*\(\s*(-*\d+\.\d\d+)s elapsed\)/ ) {
431                 $InitTime = $1; $InitElapsed = $2;
432             } elsif ( /^\s*MUT\s+time\s*(-*\d+\.\d\d+)s\s*\(\s*(-*\d+\.\d\d+)s elapsed\)/ ) {
433                 $MutTime = $1; $MutElapsed = $2;
434             } elsif ( /^\s*MUT\+GC0\s+time\s*(-*\d+\.\d\d+)s\s*\(\s*(-*\d+\.\d\d+)s elapsed\)\s+\(\s*(-*\d+\.\d\d+)s\s+MUT\s+\+\s+(-*\d+\.\d\d+)s\s+GC0/ ) {
435                 $MutTime = $3; $MutElapsed = $2;
436                 $Gc0Time = $4; $Gc0Elapsed = 0;
437             } elsif ( /^\s*GC\s+time\s*(-*\d+\.\d\d+)s\s*\(\s*(-*\d+\.\d\d+)s elapsed\)/ ) {
438                 $GcTime = $1; $GcElapsed = $2;
439             } elsif ( /^\s*GC1\s+time\s*(-*\d+\.\d\d+)s\s*\(\s*(-*\d+\.\d\d+)s elapsed\)/ ) {
440                 $Gc1Time = $1; $Gc1Elapsed = $2;
441                 $GcTime = $Gc0Time + $Gc1Time;
442
443                 # fake GcElapsed: we don't know GcElapsed since GCs are
444                 # overlapped with mutation, so we use Gc1Elapsed instead.
445                 # All we need is that MutElapsed+GcElapsed = TotElapsed
446                 $GcElapsed = $Gc1Elapsed;
447             }
448
449             if (/Generation (\d+):\s*(\d+) collections,\s*\d+ parallel,\s*(-*\d+\.\d\d+)s\s*,\s*(-*\d+\.\d\d+)s elapsed/) {
450                 if ($1 == 0) {
451                     $GCs += $2 * $procs;
452                     $Gc0Count += $2 * $procs;
453                     $Gc0Time = $3; $Gc0Elapsed = $4;
454                 } elsif ($1 == 1) {
455                     $GCs += $2;
456                     $Gc1Count += $2;
457                     $Gc1Time = $3; $Gc1Elapsed = $4;
458                 }
459             }
460
461             if (/^\s*Gen\s+(\d+)(.\d+)?\s*(\d+) colls,\s*(local|\d+\s*par)\s+(\d+\.\d+)s\s+(\d+\.\d+)s/) {
462                 $GCs += $3;
463                 if ($1 == 0) {
464                     $Gc0Count += $3;
465                     $Gc0Time = $5; $Gc0Elapsed = $6;
466                 } elsif ($1 == 1) {
467                     $Gc1Count += $3;
468                     $Gc1Time = $5; $Gc1Elapsed = $6;
469                 }
470             }
471
472             if (/work balance: ([0-9.]+)/) {
473                 $Balance = $1;
474             }
475
476             if ( /CPU GC counters/ ) {
477                 # Counters that follow correspond to GC
478                 $into_gc_counters = 1;
479             }
480
481             if ( /^\s+\(([A-Z_0-9]+)\)\s+:\s+([0-9,]+)/ ) {
482                 $counter = $1;
483                 $count   = $2;
484                 $count =~ s/,//g; # Remove commas in numbers
485                 # Pretty printing elements of a list with type [(String,[Float])]
486                 # It's a bit lame for passing values but it works.
487                 if($into_gc_counters) {
488                     $counters = "$counters(\"GC:$counter\",[$count]),";
489                 } else {
490                     $counters = "$counters(\"$counter\",[$count]),";
491                 }
492             }
493
494             if ( /^\s+\(([A-Z_0-9]+)\)\s+\%\s+of\s+\(([A-Z_0-9]+)\)\s+:\s+([0-9.]+)/ ) {
495                 $counter = "$1/$2"; # Relative quantity
496                 $count   = $3;
497                 # Pretty printing elements of a list with type [(String,[Float])]
498                 # It's a bit lame for passing values but it works.
499                 if($into_gc_counters) {
500                     $counters = "$counters(\"GC:$counter\",[$count]),";
501                 } else {
502                     $counters = "$counters(\"$counter\",[$count]),";
503                 }
504             }
505
506         }
507         close(STATS) || die "Failed when closing $StatsFile\n";
508         if ( $tot_samples > 0 ) {
509             # This is only hit for -S
510             $ResidencySamples = $tot_samples;
511             $MaxResidency = $max_live;
512             $AvgResidency = int ($tot_live / $tot_samples) ;
513         }
514
515         if ( length($counters) == 0 ) {
516             $Counters = "";
517         } else {
518             chop($counters); # remove trailing comma from the last entry
519             $Counters = " [$counters]";
520         }
521
522     } elsif ( $SysSpecificTiming eq 'hbc' ) {
523
524         open(STATS, $StatsFile) || die "Failed when opening $StatsFile\n";
525         while (<STATS>) {
526             $BytesAlloc = $1 if /^\s*([0-9]+) bytes allocated from the heap/;
527
528             $GCs = $1 if /^\s*([0-9]+) GCs?,$/;
529
530             if ( /^\s*(\d+\.\d\d+) \((\d+\.\d)\) seconds total time,$/ ) {
531                 $MutTime = $1; $MutElapsed = $2; # will fix up later
532
533                 $InitTime = 0; $InitElapsed = 0; # hbc doesn't report these
534
535             } elsif ( /^\s*(\d+\.\d\d+) \((\d+\.\d)\) seconds GC time/ ) {
536                 $GcTime = $1; $GcElapsed = $2;
537
538                 # fix up mutator time now
539                 $MutTime    = sprintf("%.2f", ($MutTime    - $GcTime));
540                 $MutElapsed = sprintf("%.1f", ($MutElapsed - $GcElapsed));
541             }
542         }
543         close(STATS) || die "Failed when closing $StatsFile\n";
544     }
545
546     # warn about what we didn't find
547     print STDERR "Warning: BytesAlloc not found in stats file\n" unless defined($BytesAlloc);
548     print STDERR "Warning: GCs not found in stats file\n" unless defined($GCs);
549     print STDERR "Warning: InitTime not found in stats file\n" unless defined($InitTime);
550     print STDERR "Warning: InitElapsed not found in stats file\n" unless defined($InitElapsed);
551     print STDERR "Warning: MutTime not found in stats file\n" unless defined($MutTime);
552     print STDERR "Warning: MutElapsed not found in stats file\n" unless defined($MutElapsed);
553     print STDERR "Warning: GcTime inot found in stats file\n" unless defined($GcTime);
554     print STDERR "Warning: GcElapsed not found in stats file\n" unless defined($GcElapsed);
555     print STDERR "Warning: total memory not found in stats file\n" unless defined($TotMem);
556     print STDERR "Warning: GC work not found in stats file\n" unless defined($GCWork);
557     print STDERR "Warning: Gc0Time not found in stats file\n" unless defined($Gc0Time);
558     print STDERR "Warning: Gc0Elapsed not found in stats file\n" unless defined($Gc0Elapsed);
559     print STDERR "Warning: Gc1Time not found in stats file\n" unless defined($Gc1Time);
560     print STDERR "Warning: Gc1Elapsed not found in stats file\n" unless defined($Gc1Elapsed);
561     print STDERR "Warning: Balance not found in stats file\n" unless defined($Gc1Elapsed);
562
563     # things we didn't necessarily expect to find
564     $MaxResidency     = 0 unless defined($MaxResidency);
565     $AvgResidency     = 0 unless defined($AvgResidency);
566     $ResidencySamples = 0 unless defined($ResidencySamples);
567     $Gc0Time          = 0.0 unless defined($Gc0Time);
568     $Gc0Elapsed       = 0.0 unless defined($Gc0Elapsed);
569     $Gc1Time          = 0.0 unless defined($Gc1Time);
570     $Gc1Elapsed       = 0.0 unless defined($Gc1Elapsed);
571     $Gc0Count         = 0 unless defined($Gc0Count);
572     $Gc1Count         = 0 unless defined($Gc1Count);
573
574     # a bit of tidying
575     $BytesAlloc =~ s/,//g;
576     $MaxResidency =~ s/,//g;
577     $GCs =~ s/,//g;
578     $InitTime =~ s/,//g;
579     $InitElapsed =~ s/,//g;
580     $MutTime =~ s/,//g;
581     $MutElapsed =~ s/,//g;
582     $GcTime =~ s/,//g;
583     $GcElapsed =~ s/,//g;
584 }
585
586 sub process_cachegrind_files {
587
588     open(STATS, "< $CachegrindStats") || die("Can't open $CachegrindStats\n");
589
590     while (<STATS>) {
591         /^==\d+==\s+I\s+refs:\s+([0-9,]*)/ && do {
592            $TotInstrs = $1;
593            $TotInstrs =~ s/,//g;
594         };
595
596         /^==\d+==\s+D\s+refs:\s+[0-9,]+\s+\(([0-9,]+)\s+rd\s+\+\s+([0-9,]+)\s+wr/ && do {
597            $TotReads  = $1;
598            $TotWrites = $2;
599            $TotReads  =~ s/,//g;
600            $TotWrites =~ s/,//g;
601         };
602
603         /^==\d+==\s+L2|Ld\s+misses:\s+([0-9,]+)/ && do {
604            $TotMisses = $1;
605            $TotMisses =~ s/,//g;
606         };
607     }
608     close(STATS);
609 }
610