perf/vg_perf.in

   1 #! @PERL@
   2 ##--------------------------------------------------------------------##
   3 ##--- Valgrind performance testing script                  vg_perf ---##
   4 ##--------------------------------------------------------------------##
   5
   6 #  This file is part of Valgrind, a dynamic binary instrumentation
   7 #  framework.
   8 #
   9 #  Copyright (C) 2005-2017 Nicholas Nethercote
  10 #     njn@valgrind.org
  11 #
  12 #  This program is free software; you can redistribute it and/or
  13 #  modify it under the terms of the GNU General Public License as
  14 #  published by the Free Software Foundation; either version 2 of the
  15 #  License, or (at your option) any later version.
  16 #
  17 #  This program is distributed in the hope that it will be useful, but
  18 #  WITHOUT ANY WARRANTY; without even the implied warranty of
  19 #  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  20 #  General Public License for more details.
  21 #
  22 #  You should have received a copy of the GNU General Public License
  23 #  along with this program; if not, see <http://www.gnu.org/licenses/>.
  24 #
  25 #  The GNU General Public License is contained in the file COPYING.
  26
  27 #----------------------------------------------------------------------------
  28 # usage: see usage message.
  29 #
  30 # You can specify individual files to test, or whole directories, or both.
  31 # Directories are traversed recursively, except for ones named, for example,
  32 # CVS/ or docs/.
  33 #
  34 # Each test is defined in a file <test>.vgperf, containing one or more of the
  35 # following lines, in any order:
  36 #   - prog:   <prog to run>                         (compulsory)
  37 #   - args:   <args for prog>                       (default: none)
  38 #   - vgopts: <Valgrind options>                    (default: none)
  39 #   - prereq: <prerequisite command>                (default: none)
  40 #   - cleanup: <post-test cleanup cmd to run>       (default: none)
  41 #
  42 # The prerequisite command, if present, must return 0 otherwise the test is
  43 # skipped.
  44 # Sometimes it is useful to run all the tests at a high sanity check
  45 # level or with arbitrary other flags.  To make this simple, extra
  46 # options, applied to all tests run, are read from $EXTRA_REGTEST_OPTS,
  47 # and handed to valgrind prior to any other flags specified by the
  48 # .vgperf file. Note: the env var is the same as vg_regtest.
  49 #----------------------------------------------------------------------------
  50
  51 use warnings;
  52 use strict;
  53
  54 #----------------------------------------------------------------------------
  55 # Global vars
  56 #----------------------------------------------------------------------------
  57 my $usage = <<END
  58 usage: vg_perf [options] [files or dirs]
  59
  60   options for the user, with defaults in [ ], are:
  61     -h --help             show this message
  62     --reps=<n>            number of repeats for each program [1]
  63     --tools=<t1,t2,t3>    tools to run [Nulgrind and Memcheck]
  64     --vg=<dir>            top-level directory containing Valgrind to measure
  65                           [Valgrind in the current directory, i.e. --vg=.]
  66                           Can be specified multiple times.
  67                           The "in-place" build is used.
  68     --terse: terse output. Prints only program name and speedup's for specified
  69       tools.
  70
  71     --outer-valgrind: run these Valgrind(s) under the given outer valgrind.
  72       These Valgrind(s) must be configured with --enable-inner.
  73     --outer-tool: tool to use by the outer valgrind (default cachegrind).
  74     --outer-args: use this as outer tool args. If the outer args are starting
  75       with +, the given outer args are appended to the outer args predefined
  76       by vg_perf.
  77
  78   Any tools named in --tools must be present in all directories specified
  79   with --vg.  (This is not checked.)
  80   Use EXTRA_REGTEST_OPTS to supply extra args for all tests
  81 END
  82 ;
  83
  84 # Test variables
  85 my $vgopts;             # valgrind options
  86 my $prog;               # test prog
  87 my $args;               # test prog args
  88 my $prereq;             # prerequisite test to satisfy before running test
  89 my $cleanup;            # cleanup command to run
  90
  91 # Command line options
  92 my $n_reps = 1;         # Run each test $n_reps times and choose the best one.
  93 my @vgdirs;             # Dirs of the various Valgrinds being measured.
  94 my @tools = ("none", "memcheck");   # tools being measured
  95 my $terse = 0;          # Terse output.
  96
  97 # Outer valgrind to use, and args to use for it.
  98 # If this is set, --valgrind should be set to the installed inner valgrind,
  99 # and --valgrind-lib will be ignore
 100 my $outer_valgrind;
 101 my $outer_tool = "cachegrind";
 102 my $outer_args;
 103
 104
 105 my $num_tests_done   = 0;
 106 my $num_timings_done = 0;
 107
 108 # Starting directory
 109 chomp(my $tests_dir = `pwd`);
 110
 111 #----------------------------------------------------------------------------
 112 # Process command line, setup
 113 #----------------------------------------------------------------------------
 114
 115 # If $prog is a relative path, it prepends $dir to it.  Useful for two reasons:
 116 #
 117 # 1. Can prepend "." onto programs to avoid trouble with users who don't have
 118 #    "." in their path (by making $dir = ".")
 119 # 2. Can prepend the current dir to make the command absolute to avoid
 120 #    subsequent trouble when we change directories.
 121 #
 122 # Also checks the program exists and is executable.
 123 sub validate_program ($$$$)
 124 {
 125     my ($dir, $prog, $must_exist, $must_be_executable) = @_;
 126
 127     # If absolute path, leave it alone.  If relative, make it
 128     # absolute -- by prepending current dir -- so we can change
 129     # dirs and still use it.
 130     $prog = "$dir/$prog" if ($prog !~ /^\//);
 131     if ($must_exist) {
 132         (-f $prog) or die "vg_perf: '$prog' not found or not a file ($dir)\n";
 133     }
 134     if ($must_be_executable) {
 135         (-x $prog) or die "vg_perf: '$prog' not executable ($dir)\n";
 136     }
 137
 138     return $prog;
 139 }
 140
 141 sub add_vgdir($)
 142 {
 143     my ($vgdir) = @_;
 144     if ($vgdir !~ /^\//) { $vgdir = "$tests_dir/$vgdir"; }
 145     push(@vgdirs, $vgdir);
 146 }
 147
 148 sub process_command_line()
 149 {
 150     my @fs;
 151
 152     for my $arg (@ARGV) {
 153         if ($arg =~ /^-/) {
 154             if ($arg =~ /^--reps=(\d+)$/) {
 155                 $n_reps = $1;
 156                 if ($n_reps < 1) { die "bad --reps value: $n_reps\n"; }
 157             } elsif ($arg =~ /^--vg=(.+)$/) {
 158                 # Make dir absolute if not already
 159                 add_vgdir($1);
 160             } elsif ($arg =~ /^--tools=(.+)$/) {
 161                 @tools = split(/,/, $1);
 162             } elsif ($arg =~ /^--terse$/) {
 163                 $terse = 1;
 164             } elsif ($arg =~ /^--outer-valgrind=(.*)$/) {
 165                 $outer_valgrind = $1;
 166             } elsif ($arg =~ /^--outer-tool=(.*)$/) {
 167                 $outer_tool = $1;
 168             } elsif ($arg =~ /^--outer-args=(.*)$/) {
 169                 $outer_args = $1;
 170             } else {
 171                 die $usage;
 172             }
 173         } else {
 174             push(@fs, $arg);
 175         }
 176     }
 177
 178     # If no --vg options were specified, use the current tree.
 179     if (0 == @vgdirs) {
 180         add_vgdir($tests_dir);
 181     }
 182
 183     (0 != @fs) or die "No test files or directories specified\n";
 184
 185     return @fs;
 186 }
 187
 188 #----------------------------------------------------------------------------
 189 # Read a .vgperf file
 190 #----------------------------------------------------------------------------
 191 sub read_vgperf_file($)
 192 {
 193     my ($f) = @_;
 194
 195     # Defaults.
 196     ($vgopts, $prog, $args, $prereq, $cleanup)
 197       = ("", undef, "", undef, undef, undef, undef);
 198
 199     open(INPUTFILE, "< $f") || die "File $f not openable\n";
 200
 201     while (my $line = <INPUTFILE>) {
 202         if      ($line =~ /^\s*#/ || $line =~ /^\s*$/) {
 203             next;
 204         } elsif ($line =~ /^\s*vgopts:\s*(.*)$/) {
 205             $vgopts = $1;
 206         } elsif ($line =~ /^\s*prog:\s*(.*)$/) {
 207             $prog = validate_program(".", $1, 1, 1);
 208         } elsif ($line =~ /^\s*args:\s*(.*)$/) {
 209             $args = $1;
 210         } elsif ($line =~ /^\s*prereq:\s*(.*)$/) {
 211             $prereq = $1;
 212         } elsif ($line =~ /^\s*cleanup:\s*(.*)$/) {
 213             $cleanup = $1;
 214         } else {
 215             die "Bad line in $f: $line\n";
 216         }
 217     }
 218     close(INPUTFILE);
 219
 220     if (!defined $prog) {
 221         $prog = "";     # allow no prog for testing error and --help cases
 222     }
 223     if (0 == @tools) {
 224         die "vg_perf: missing 'tools' line in $f\n";
 225     }
 226 }
 227
 228 #----------------------------------------------------------------------------
 229 # Do one test
 230 #----------------------------------------------------------------------------
 231 # Since most of the program time is spent in system() calls, need this to
 232 # propagate a Ctrl-C enabling us to quit.
 233 sub mysystem($)
 234 {
 235     my ($cmd) = @_;
 236     my $retval = system($cmd);
 237     if ($retval == 2) {
 238         exit 1;
 239     } else {
 240         return $retval;
 241     }
 242 }
 243
 244 # Run program N times, return the best user time.  Use the POSIX
 245 # -p flag on /usr/bin/time so as to get something parseable on AIX.
 246 sub time_prog($$)
 247 {
 248     my ($cmd, $n) = @_;
 249     my $tmin = 999999;
 250     for (my $i = 0; $i < $n; $i++) {
 251         mysystem("echo '$cmd' > perf.cmd");
 252         my $retval = mysystem("$cmd > perf.stdout 2> perf.stderr");
 253         (0 == $retval) or
 254             die "\n*** Command returned non-zero ($retval)"
 255               . "\n*** See perf.{cmd,stdout,stderr} to determine what went wrong.\n";
 256         my $out = `cat perf.stderr`;
 257         ($out =~ /[Uu]ser +([\d\.]+)/) or
 258             die "\n*** missing usertime in perf.stderr\n";
 259         $tmin = $1 if ($1 < $tmin);
 260     }
 261
 262     # Successful run; cleanup
 263     unlink("perf.cmd");
 264     unlink("perf.stderr");
 265     unlink("perf.stdout");
 266
 267     # Avoid divisions by zero!
 268     return (0 == $tmin ? 0.01 : $tmin);
 269 }
 270
 271 sub do_one_test($$)
 272 {
 273     my ($dir, $vgperf) = @_;
 274     $vgperf =~ /^(.*)\.vgperf/;
 275     my $name = $1;
 276     my %first_tTool;    # For doing percentage speedups when comparing
 277                         # multiple Valgrinds
 278
 279     read_vgperf_file($vgperf);
 280
 281     if (defined $prereq) {
 282         if (system("$prereq") != 0) {
 283             printf("%-16s (skipping, prereq failed: $prereq)\n", "$name:");
 284             return;
 285         }
 286     }
 287
 288     my $timecmd = "/usr/bin/time -p";
 289
 290     # Do the native run(s).
 291     printf("-- $name --\n") if (@vgdirs > 1);
 292     my $cmd     = "$timecmd $prog $args";
 293     my $tNative = time_prog($cmd, $n_reps);
 294
 295     if (defined $outer_valgrind) {
 296         $outer_valgrind = validate_program($tests_dir, $outer_valgrind, 1, 1);
 297         foreach my $vgdir (@vgdirs) {
 298             validate_program($vgdir, "./coregrind/valgrind", 1, 1);
 299         }
 300     } else {
 301         foreach my $vgdir (@vgdirs) {
 302             validate_program($vgdir, "./coregrind/valgrind", 1, 1);
 303         }
 304     }
 305
 306     # Pull any extra options (for example, --sanity-level=4)
 307     # from $EXTRA_REGTEST_OPTS.
 308     my $maybe_extraopts = $ENV{"EXTRA_REGTEST_OPTS"};
 309     my $extraopts = $maybe_extraopts ?  $maybe_extraopts  : "";
 310
 311     foreach my $vgdir (@vgdirs) {
 312         # Benchmark name
 313         if (!$terse) {
 314             printf("%-8s ", $name);
 315         }
 316
 317         # Print the Valgrind version if we are measuring more than one.
 318         my $vgdirname = $vgdir;
 319         chomp($vgdirname = `basename $vgdir`);
 320         printf("%-10s:", $vgdirname);
 321
 322         # Native execution time
 323         if (!$terse) {
 324             printf("%4.2fs", $tNative);
 325         }
 326
 327         foreach my $tool (@tools) {
 328             # First two chars of toolname for abbreviation
 329             my $tool_abbrev = $tool;
 330             $tool_abbrev =~ s/(..).*/$1/;
 331             printf("  %s:", $tool_abbrev);
 332             my $run_outer_args = "";
 333             if ((not defined $outer_args) || ($outer_args =~ /^\+/)) {
 334                 $run_outer_args =
 335                       " -v --command-line-only=yes"
 336                     . " --sim-hints=enable-outer"
 337                     . " --run-libc-freeres=no --run-cxx-freeres=no"
 338                     . " --smc-check=all-non-file"
 339                     . " --vgdb=no --trace-children=yes --read-var-info=no"
 340                     . " --suppressions=../tests/outer_inner.supp"
 341                     . " --memcheck:leak-check=full --memcheck:show-reachable=no"
 342                     . " --cachegrind:cache-sim=yes --cachegrind:branch-sim=yes"
 343                     . " --cachegrind:cachegrind-out-file=cachegrind.out.$vgdirname.$tool_abbrev.$name.%p"
 344                     . " --callgrind:cache-sim=yes --callgrind:branch-sim=yes"
 345                     . " --callgrind:dump-instr=yes --callgrind:collect-jumps=yes"
 346                     . " --callgrind:callgrind-out-file=callgrind.out.$vgdirname.$tool_abbrev.$name.%p"
 347                     . " ";
 348                  if (defined $outer_args) {
 349                     $outer_args =~ s/^\+(.*)/$1/;
 350                     $run_outer_args = $run_outer_args . $outer_args;
 351                  }
 352             } else {
 353                 $run_outer_args = $outer_args;
 354             }
 355
 356             my $vgsetup = "";
 357             my $vgcmd   = "$vgdir/coregrind/valgrind "
 358                         . "--command-line-only=yes --tool=$tool  $extraopts -q "
 359                         . "--memcheck:leak-check=no "
 360                         . "--trace-children=yes "
 361                         . "$vgopts ";
 362             # Do the tool run(s).
 363             if (defined $outer_valgrind ) {
 364                 # in an outer-inner setup, only set VALGRIND_LIB_INNER
 365                 $vgsetup = "VALGRIND_LIB_INNER=$vgdir/.in_place ";
 366                 $vgcmd   = "$outer_valgrind "
 367                          . "--tool=" . $outer_tool . " "
 368                          . "--log-file=" . "$outer_tool.outer.log.$vgdirname.$tool_abbrev.$name.%p "
 369                          . "$run_outer_args "
 370                          . $vgcmd;
 371             } else {
 372                 # Set both VALGRIND_LIB and VALGRIND_LIB_INNER
 373                 # in case this Valgrind was configured with --enable-inner.  And
 374                 # also VALGRINDLIB, which was the old name for the variable, to
 375                 # allow comparison against old Valgrind versions (eg. 2.4.X).
 376                 $vgsetup = "VALGRINDLIB=$vgdir/.in_place "
 377                          . "VALGRIND_LIB=$vgdir/.in_place "
 378                          . "VALGRIND_LIB_INNER=$vgdir/.in_place ";
 379             }
 380             my $cmd     = "$vgsetup $timecmd $vgcmd $prog $args";
 381             my $tTool   = time_prog($cmd, $n_reps);
 382             if (!$terse) {
 383                 printf("%4.1fs (%4.1fx,", $tTool, $tTool/$tNative);
 384             }
 385
 386             # If it's the first timing for this tool on this benchmark,
 387             # record the time so we can get the percentage speedup of the
 388             # subsequent Valgrinds.  Otherwise, compute and print
 389             # the speedup.
 390             if (not defined $first_tTool{$tool}) {
 391                 $first_tTool{$tool} = $tTool;
 392                 print(" -----");
 393             } else {
 394                 my $speedup = 100 - (100 * $tTool / $first_tTool{$tool});
 395                 printf("%5.1f%%", $speedup);
 396             }
 397             if (!$terse) {
 398                print(")");
 399             }
 400
 401             $num_timings_done++;
 402
 403             if (defined $cleanup) {
 404                 (system("$cleanup") == 0) or
 405                     print("  ($name cleanup operation failed: $cleanup)\n");
 406             }
 407         }
 408         printf("\n");
 409     }
 410
 411     $num_tests_done++;
 412 }
 413
 414 #----------------------------------------------------------------------------
 415 # Test one directory (and any subdirs)
 416 #----------------------------------------------------------------------------
 417 sub test_one_dir($$);    # forward declaration
 418
 419 sub test_one_dir($$)
 420 {
 421     my ($dir, $prev_dirs) = @_;
 422     $dir =~ s/\/$//;    # trim a trailing '/'
 423
 424     chomp(my $initial_dir = `pwd`);     # record where we started
 425
 426     # Ignore dirs into which we should not recurse.
 427     if ($dir =~ /^(BitKeeper|CVS|SCCS|docs|doc)$/) { return; }
 428
 429     chdir($dir) or die "Could not change into $dir\n";
 430
 431     # Nb: Don't prepend a '/' to the base directory
 432     my $full_dir = $prev_dirs . ($prev_dirs eq "" ? "" : "/") . $dir;
 433     my $dashes = "-" x (50 - length $full_dir);
 434
 435     my @fs = glob "*";
 436     my $found_tests = (0 != (grep { $_ =~ /\.vgperf$/ } @fs));
 437
 438     if ($found_tests) {
 439         print "-- Running  tests in $full_dir $dashes\n";
 440     }
 441     foreach my $f (@fs) {
 442         if (-d $f) {
 443             test_one_dir($f, $full_dir);
 444         } elsif ($f =~ /\.vgperf$/) {
 445             do_one_test($full_dir, $f);
 446         }
 447     }
 448     if ($found_tests) {
 449         print "-- Finished tests in $full_dir $dashes\n";
 450     }
 451
 452     chdir("$initial_dir");
 453 }
 454
 455 #----------------------------------------------------------------------------
 456 # Summarise results
 457 #----------------------------------------------------------------------------
 458 sub summarise_results
 459 {
 460     printf("\n== %d programs, %d timings =================\n\n",
 461            $num_tests_done, $num_timings_done);
 462 }
 463
 464 #----------------------------------------------------------------------------
 465 # main()
 466 #----------------------------------------------------------------------------
 467 sub warn_about_EXTRA_REGTEST_OPTS()
 468 {
 469     print "WARNING: \$EXTRA_REGTEST_OPTS is set.  You probably don't want\n";
 470     print "to run the perf tests with it set, unless you are doing some\n";
 471     print "strange experiment, and/or you really know what you are doing.\n";
 472     print "\n";
 473 }
 474
 475 # nuke VALGRIND_OPTS
 476 $ENV{"VALGRIND_OPTS"} = "";
 477
 478 if ($ENV{"EXTRA_REGTEST_OPTS"}) {
 479     print "\n";
 480     warn_about_EXTRA_REGTEST_OPTS();
 481 }
 482
 483 my @fs = process_command_line();
 484 foreach my $f (@fs) {
 485     if (-d $f) {
 486         test_one_dir($f, "");
 487     } else {
 488         # Allow the .vgperf suffix to be given or omitted
 489         if ($f =~ /.vgperf$/ && -r $f) {
 490             # do nothing
 491         } elsif (-r "$f.vgperf") {
 492             $f = "$f.vgperf";
 493         } else {
 494             die "`$f' neither a directory nor a readable test file/name\n"
 495         }
 496         my $dir  = `dirname  $f`;   chomp $dir;
 497         my $file = `basename $f`;   chomp $file;
 498         chdir($dir) or die "Could not change into $dir\n";
 499         do_one_test($dir, $file);
 500         chdir($tests_dir);
 501     }
 502 }
 503 summarise_results();
 504
 505 if ($ENV{"EXTRA_REGTEST_OPTS"}) {
 506     warn_about_EXTRA_REGTEST_OPTS();
 507 }
 508
 509 ##--------------------------------------------------------------------##
 510 ##--- end                                                          ---##
 511 ##--------------------------------------------------------------------##