648f38100075532b3e14a06dff61c9353bc5146d
[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                 $max_live = $1 if $max_live < $1;
405                 $tot_live += $1;
406                 $tot_samples += 1;
407             }
408
409             $BytesAlloc = $1 if /^\s*([0-9,]+) bytes allocated in the heap/;
410             
411             if (/^\s*([0-9,]+) bytes (copied during GC|globalised)/) {
412                $tmp = $1;
413                $tmp =~ s/,//g;
414                $GCWork += $tmp;
415             }
416
417 #           if ( /^\s*([0-9,]+) bytes maximum residency .* (\d+) sample/ ) {
418 #               $MaxResidency = $1; $ResidencySamples = $2;
419 #           }
420
421             if ( /^\s+([0-9]+)\s+M[Bb] total memory/ ) {
422                 $TotMem = $1;
423             }
424
425             if ( /^\s*INIT\s+time\s*(-*\d+\.\d\d+)s\s*\(\s*(-*\d+\.\d\d+)s elapsed\)/ ) {
426                 $InitTime = $1; $InitElapsed = $2;
427             } elsif ( /^\s*MUT\s+time\s*(-*\d+\.\d\d+)s\s*\(\s*(-*\d+\.\d\d+)s elapsed\)/ ) {
428                 $MutTime = $1; $MutElapsed = $2;
429             } 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/ ) {
430                 $MutTime = $3; $MutElapsed = $2;
431                 $Gc0Time = $4; $Gc0Elapsed = 0;
432             } elsif ( /^\s*GC\s+time\s*(-*\d+\.\d\d+)s\s*\(\s*(-*\d+\.\d\d+)s elapsed\)/ ) {
433                 $GcTime = $1; $GcElapsed = $2;
434             } elsif ( /^\s*GC1\s+time\s*(-*\d+\.\d\d+)s\s*\(\s*(-*\d+\.\d\d+)s elapsed\)/ ) {
435                 $Gc1Time = $1; $Gc1Elapsed = $2;
436                 $GcTime = $Gc0Time + $Gc1Time;
437
438                 # fake GcElapsed: we don't know GcElapsed since GCs are
439                 # overlapped with mutation, so we use Gc1Elapsed instead.
440                 # All we need is that MutElapsed+GcElapsed = TotElapsed
441                 $GcElapsed = $Gc1Elapsed;
442             }
443
444             if (/Generation (\d+):\s*(\d+) collections,\s*\d+ parallel,\s*(-*\d+\.\d\d+)s\s*,\s*(-*\d+\.\d\d+)s elapsed/) {
445                 if ($1 == 0) {
446                     $GCs += $2 * $procs;
447                     $Gc0Count += $2 * $procs;
448                     $Gc0Time = $3; $Gc0Elapsed = $4;
449                 } elsif ($1 == 1) {
450                     $GCs += $2;
451                     $Gc1Count += $2;
452                     $Gc1Time = $3; $Gc1Elapsed = $4;
453                 }
454             }
455
456             if (/^\s*Gen\s+(\d+)(.\d+)?\s*(\d+) colls,\s*(local|\d+\s*par)\s+(\d+\.\d+)s\s+(\d+\.\d+)s/) {
457                 $GCs += $3;
458                 if ($1 == 0) {
459                     $Gc0Count += $3;
460                     $Gc0Time = $5; $Gc0Elapsed = $6;
461                 } elsif ($1 == 1) {
462                     $Gc1Count += $3;
463                     $Gc1Time = $5; $Gc1Elapsed = $6;
464                 }
465             }
466
467             if (/work balance: ([0-9.]+)/) {
468                 $Balance = $1;
469             }
470
471             if ( /CPU GC counters/ ) {
472                 # Counters that follow correspond to GC
473                 $into_gc_counters = 1;
474             }
475
476             if ( /^\s+\(([A-Z_0-9]+)\)\s+:\s+([0-9,]+)/ ) {
477                 $counter = $1;
478                 $count   = $2;
479                 $count =~ s/,//g; # Remove commas in numbers
480                 # Pretty printing elements of a list with type [(String,[Float])]
481                 # It's a bit lame for passing values but it works.
482                 if($into_gc_counters) {
483                     $counters = "$counters(\"GC:$counter\",[$count]),";
484                 } else {
485                     $counters = "$counters(\"$counter\",[$count]),";
486                 }
487             }
488
489             if ( /^\s+\(([A-Z_0-9]+)\)\s+\%\s+of\s+\(([A-Z_0-9]+)\)\s+:\s+([0-9.]+)/ ) {
490                 $counter = "$1/$2"; # Relative quantity
491                 $count   = $3;
492                 # Pretty printing elements of a list with type [(String,[Float])]
493                 # It's a bit lame for passing values but it works.
494                 if($into_gc_counters) {
495                     $counters = "$counters(\"GC:$counter\",[$count]),";
496                 } else {
497                     $counters = "$counters(\"$counter\",[$count]),";
498                 }
499             }
500
501         }
502         close(STATS) || die "Failed when closing $StatsFile\n";
503         if ( $tot_samples > 0 ) {
504             $ResidencySamples = $tot_samples;
505             $MaxResidency = $max_live;
506             $AvgResidency = int ($tot_live / $tot_samples) ;
507         }
508
509         if ( length($counters) == 0 ) {
510             $Counters = "";
511         } else {
512             chop($counters); # remove trailing comma from the last entry
513             $Counters = " [$counters]";
514         }
515
516     } elsif ( $SysSpecificTiming eq 'hbc' ) {
517
518         open(STATS, $StatsFile) || die "Failed when opening $StatsFile\n";
519         while (<STATS>) {
520             $BytesAlloc = $1 if /^\s*([0-9]+) bytes allocated from the heap/;
521
522             $GCs = $1 if /^\s*([0-9]+) GCs?,$/;
523
524             if ( /^\s*(\d+\.\d\d+) \((\d+\.\d)\) seconds total time,$/ ) {
525                 $MutTime = $1; $MutElapsed = $2; # will fix up later
526
527                 $InitTime = 0; $InitElapsed = 0; # hbc doesn't report these
528
529             } elsif ( /^\s*(\d+\.\d\d+) \((\d+\.\d)\) seconds GC time/ ) {
530                 $GcTime = $1; $GcElapsed = $2;
531
532                 # fix up mutator time now
533                 $MutTime    = sprintf("%.2f", ($MutTime    - $GcTime));
534                 $MutElapsed = sprintf("%.1f", ($MutElapsed - $GcElapsed));
535             }
536         }
537         close(STATS) || die "Failed when closing $StatsFile\n";
538     }
539
540     # warn about what we didn't find
541     print STDERR "Warning: BytesAlloc not found in stats file\n" unless defined($BytesAlloc);
542     print STDERR "Warning: GCs not found in stats file\n" unless defined($GCs);
543     print STDERR "Warning: InitTime not found in stats file\n" unless defined($InitTime);
544     print STDERR "Warning: InitElapsed not found in stats file\n" unless defined($InitElapsed);
545     print STDERR "Warning: MutTime not found in stats file\n" unless defined($MutTime);
546     print STDERR "Warning: MutElapsed not found in stats file\n" unless defined($MutElapsed);
547     print STDERR "Warning: GcTime inot found in stats file\n" unless defined($GcTime);
548     print STDERR "Warning: GcElapsed not found in stats file\n" unless defined($GcElapsed);
549     print STDERR "Warning: total memory not found in stats file\n" unless defined($TotMem);
550     print STDERR "Warning: GC work not found in stats file\n" unless defined($GCWork);
551     print STDERR "Warning: Gc0Time not found in stats file\n" unless defined($Gc0Time);
552     print STDERR "Warning: Gc0Elapsed not found in stats file\n" unless defined($Gc0Elapsed);
553     print STDERR "Warning: Gc1Time not found in stats file\n" unless defined($Gc1Time);
554     print STDERR "Warning: Gc1Elapsed not found in stats file\n" unless defined($Gc1Elapsed);
555     print STDERR "Warning: Balance not found in stats file\n" unless defined($Gc1Elapsed);
556
557     # things we didn't necessarily expect to find
558     $MaxResidency     = 0 unless defined($MaxResidency);
559     $AvgResidency     = 0 unless defined($AvgResidency);
560     $ResidencySamples = 0 unless defined($ResidencySamples);
561     $Gc0Time          = 0.0 unless defined($Gc0Time);
562     $Gc0Elapsed       = 0.0 unless defined($Gc0Elapsed);
563     $Gc1Time          = 0.0 unless defined($Gc1Time);
564     $Gc1Elapsed       = 0.0 unless defined($Gc1Elapsed);
565     $Gc0Count         = 0 unless defined($Gc0Count);
566     $Gc1Count         = 0 unless defined($Gc1Count);
567
568     # a bit of tidying
569     $BytesAlloc =~ s/,//g;
570     $MaxResidency =~ s/,//g;
571     $GCs =~ s/,//g;
572     $InitTime =~ s/,//g;
573     $InitElapsed =~ s/,//g;
574     $MutTime =~ s/,//g;
575     $MutElapsed =~ s/,//g;
576     $GcTime =~ s/,//g;
577     $GcElapsed =~ s/,//g;
578 }
579
580 sub process_cachegrind_files {
581
582     open(STATS, "< $CachegrindStats") || die("Can't open $CachegrindStats\n");
583
584     while (<STATS>) {
585         /^==\d+==\s+I\s+refs:\s+([0-9,]*)/ && do {
586            $TotInstrs = $1;
587            $TotInstrs =~ s/,//g;
588         };
589
590         /^==\d+==\s+D\s+refs:\s+[0-9,]+\s+\(([0-9,]+)\s+rd\s+\+\s+([0-9,]+)\s+wr/ && do {
591            $TotReads  = $1;
592            $TotWrites = $2;
593            $TotReads  =~ s/,//g;
594            $TotWrites =~ s/,//g;
595         };
596
597         /^==\d+==\s+L2|Ld\s+misses:\s+([0-9,]+)/ && do {
598            $TotMisses = $1;
599            $TotMisses =~ s/,//g;
600         };
601     }
602     close(STATS);
603 }
604