git.oblomov.eu Git - git/blob - t/perf/aggregate.perl

   1 #!/usr/bin/perl
   2
   3 use lib '../../perl/build/lib';
   4 use strict;
   5 use warnings;
   6 use Getopt::Long;
   7 use Cwd qw(realpath);
   8
   9 sub get_times {
  10         my $name = shift;
  11         open my $fh, "<", $name or return undef;
  12         my $line = <$fh>;
  13         return undef if not defined $line;
  14         close $fh or die "cannot close $name: $!";
  15         # times
  16         if ($line =~ /^(?:(\d+):)?(\d+):(\d+(?:\.\d+)?) (\d+(?:\.\d+)?) (\d+(?:\.\d+)?)$/) {
  17                 my $rt = ((defined $1 ? $1 : 0.0)*60+$2)*60+$3;
  18                 return ($rt, $4, $5);
  19         # size
  20         } elsif ($line =~ /^\d+$/) {
  21                 return $&;
  22         } else {
  23                 die "bad input line: $line";
  24         }
  25 }
  26
  27 sub relative_change {
  28         my ($r, $firstr) = @_;
  29         if ($firstr > 0) {
  30                 return sprintf "%+.1f%%", 100.0*($r-$firstr)/$firstr;
  31         } elsif ($r == 0) {
  32                 return "=";
  33         } else {
  34                 return "+inf";
  35         }
  36 }
  37
  38 sub format_times {
  39         my ($r, $u, $s, $firstr) = @_;
  40         # no value means we did not finish the test
  41         if (!defined $r) {
  42                 return "<missing>";
  43         }
  44         # a single value means we have a size, not times
  45         if (!defined $u) {
  46                 return format_size($r, $firstr);
  47         }
  48         # otherwise, we have real/user/system times
  49         my $out = sprintf "%.2f(%.2f+%.2f)", $r, $u, $s;
  50         $out .= ' ' . relative_change($r, $firstr) if defined $firstr;
  51         return $out;
  52 }
  53
  54 sub usage {
  55         print <<EOT;
  56 ./aggregate.perl [options] [--] [<dir_or_rev>...] [--] [<test_script>...] >
  57
  58   Options:
  59     --codespeed          * Format output for Codespeed
  60     --reponame    <str>  * Send given reponame to codespeed
  61     --sort-by     <str>  * Sort output (only "regression" criteria is supported)
  62     --subsection  <str>  * Use results from given subsection
  63
  64 EOT
  65         exit(1);
  66 }
  67
  68 sub human_size {
  69         my $n = shift;
  70         my @units = ('', qw(K M G));
  71         while ($n > 900 && @units > 1) {
  72                 $n /= 1000;
  73                 shift @units;
  74         }
  75         return $n unless length $units[0];
  76         return sprintf '%.1f%s', $n, $units[0];
  77 }
  78
  79 sub format_size {
  80         my ($size, $first) = @_;
  81         # match the width of a time: 0.00(0.00+0.00)
  82         my $out = sprintf '%15s', human_size($size);
  83         $out .= ' ' . relative_change($size, $first) if defined $first;
  84         return $out;
  85 }
  86
  87 sub sane_backticks {
  88         open(my $fh, '-|', @_);
  89         return <$fh>;
  90 }
  91
  92 my (@dirs, %dirnames, %dirabbrevs, %prefixes, @tests,
  93     $codespeed, $sortby, $subsection, $reponame);
  94
  95 Getopt::Long::Configure qw/ require_order /;
  96
  97 my $rc = GetOptions("codespeed"     => \$codespeed,
  98                     "reponame=s"    => \$reponame,
  99                     "sort-by=s"     => \$sortby,
 100                     "subsection=s"  => \$subsection);
 101 usage() unless $rc;
 102
 103 while (scalar @ARGV) {
 104         my $arg = $ARGV[0];
 105         my $dir;
 106         my $prefix = '';
 107         last if -f $arg or $arg eq "--";
 108         if (! -d $arg) {
 109                 my $rev = sane_backticks(qw(git rev-parse --verify), $arg);
 110                 chomp $rev;
 111                 $dir = "build/".$rev;
 112         } elsif ($arg eq '.') {
 113                 $dir = '.';
 114         } else {
 115                 $dir = realpath($arg);
 116                 $dirnames{$dir} = $dir;
 117                 $prefix .= 'bindir';
 118         }
 119         push @dirs, $dir;
 120         $dirnames{$dir} ||= $arg;
 121         $prefix .= $dir;
 122         $prefix =~ tr/^a-zA-Z0-9/_/c;
 123         $prefixes{$dir} = $prefix . '.';
 124         shift @ARGV;
 125 }
 126
 127 if (not @dirs) {
 128         @dirs = ('.');
 129 }
 130 $dirnames{'.'} = $dirabbrevs{'.'} = "this tree";
 131 $prefixes{'.'} = '';
 132
 133 shift @ARGV if scalar @ARGV and $ARGV[0] eq "--";
 134
 135 @tests = @ARGV;
 136 if (not @tests) {
 137         @tests = glob "p????-*.sh";
 138 }
 139
 140 my $resultsdir = "test-results";
 141
 142 if (! $subsection and
 143     exists $ENV{GIT_PERF_SUBSECTION} and
 144     $ENV{GIT_PERF_SUBSECTION} ne "") {
 145         $subsection = $ENV{GIT_PERF_SUBSECTION};
 146 }
 147
 148 if ($subsection) {
 149         $resultsdir .= "/" . $subsection;
 150 }
 151
 152 my @subtests;
 153 my %shorttests;
 154 for my $t (@tests) {
 155         $t =~ s{(?:.*/)?(p(\d+)-[^/]+)\.sh$}{$1} or die "bad test name: $t";
 156         my $n = $2;
 157         my $fname = "$resultsdir/$t.subtests";
 158         open my $fp, "<", $fname or die "cannot open $fname: $!";
 159         for (<$fp>) {
 160                 chomp;
 161                 /^(\d+)$/ or die "malformed subtest line: $_";
 162                 push @subtests, "$t.$1";
 163                 $shorttests{"$t.$1"} = "$n.$1";
 164         }
 165         close $fp or die "cannot close $fname: $!";
 166 }
 167
 168 sub read_descr {
 169         my $name = shift;
 170         open my $fh, "<", $name or return "<error reading description>";
 171         binmode $fh, ":utf8" or die "PANIC on binmode: $!";
 172         my $line = <$fh>;
 173         close $fh or die "cannot close $name";
 174         chomp $line;
 175         return $line;
 176 }
 177
 178 sub have_duplicate {
 179         my %seen;
 180         for (@_) {
 181                 return 1 if exists $seen{$_};
 182                 $seen{$_} = 1;
 183         }
 184         return 0;
 185 }
 186 sub have_slash {
 187         for (@_) {
 188                 return 1 if m{/};
 189         }
 190         return 0;
 191 }
 192
 193 sub display_dir {
 194         my ($d) = @_;
 195         return exists $dirabbrevs{$d} ? $dirabbrevs{$d} : $dirnames{$d};
 196 }
 197
 198 sub print_default_results {
 199         my %descrs;
 200         my $descrlen = 4; # "Test"
 201         for my $t (@subtests) {
 202                 $descrs{$t} = $shorttests{$t}.": ".read_descr("$resultsdir/$t.descr");
 203                 $descrlen = length $descrs{$t} if length $descrs{$t}>$descrlen;
 204         }
 205
 206         my %newdirabbrevs = %dirabbrevs;
 207         while (!have_duplicate(values %newdirabbrevs)) {
 208                 %dirabbrevs = %newdirabbrevs;
 209                 last if !have_slash(values %dirabbrevs);
 210                 %newdirabbrevs = %dirabbrevs;
 211                 for (values %newdirabbrevs) {
 212                         s{^[^/]*/}{};
 213                 }
 214         }
 215
 216         my %times;
 217         my @colwidth = ((0)x@dirs);
 218         for my $i (0..$#dirs) {
 219                 my $w = length display_dir($dirs[$i]);
 220                 $colwidth[$i] = $w if $w > $colwidth[$i];
 221         }
 222         for my $t (@subtests) {
 223                 my $firstr;
 224                 for my $i (0..$#dirs) {
 225                         my $d = $dirs[$i];
 226                         my $base = "$resultsdir/$prefixes{$d}$t";
 227                         $times{$prefixes{$d}.$t} = [];
 228                         foreach my $type (qw(times size)) {
 229                                 if (-e "$base.$type") {
 230                                         $times{$prefixes{$d}.$t} = [get_times("$base.$type")];
 231                                         last;
 232                                 }
 233                         }
 234                         my ($r,$u,$s) = @{$times{$prefixes{$d}.$t}};
 235                         my $w = length format_times($r,$u,$s,$firstr);
 236                         $colwidth[$i] = $w if $w > $colwidth[$i];
 237                         $firstr = $r unless defined $firstr;
 238                 }
 239         }
 240         my $totalwidth = 3*@dirs+$descrlen;
 241         $totalwidth += $_ for (@colwidth);
 242
 243         printf "%-${descrlen}s", "Test";
 244         for my $i (0..$#dirs) {
 245                 printf "   %-$colwidth[$i]s", display_dir($dirs[$i]);
 246         }
 247         print "\n";
 248         print "-"x$totalwidth, "\n";
 249         for my $t (@subtests) {
 250                 printf "%-${descrlen}s", $descrs{$t};
 251                 my $firstr;
 252                 for my $i (0..$#dirs) {
 253                         my $d = $dirs[$i];
 254                         my ($r,$u,$s) = @{$times{$prefixes{$d}.$t}};
 255                         printf "   %-$colwidth[$i]s", format_times($r,$u,$s,$firstr);
 256                         $firstr = $r unless defined $firstr;
 257                 }
 258                 print "\n";
 259         }
 260 }
 261
 262 sub print_sorted_results {
 263         my ($sortby) = @_;
 264
 265         if ($sortby ne "regression") {
 266                 print "Only 'regression' is supported as '--sort-by' argument\n";
 267                 usage();
 268         }
 269
 270         my @evolutions;
 271         for my $t (@subtests) {
 272                 my ($prevr, $prevu, $prevs, $prevrev);
 273                 for my $i (0..$#dirs) {
 274                         my $d = $dirs[$i];
 275                         my ($r, $u, $s) = get_times("$resultsdir/$prefixes{$d}$t.times");
 276                         if ($i > 0 and defined $r and defined $prevr and $prevr > 0) {
 277                                 my $percent = 100.0 * ($r - $prevr) / $prevr;
 278                                 push @evolutions, { "percent"  => $percent,
 279                                                     "test"     => $t,
 280                                                     "prevrev"  => $prevrev,
 281                                                     "rev"      => $d,
 282                                                     "prevr"    => $prevr,
 283                                                     "r"        => $r,
 284                                                     "prevu"    => $prevu,
 285                                                     "u"        => $u,
 286                                                     "prevs"    => $prevs,
 287                                                     "s"        => $s};
 288                         }
 289                         ($prevr, $prevu, $prevs, $prevrev) = ($r, $u, $s, $d);
 290                 }
 291         }
 292
 293         my @sorted_evolutions = sort { $b->{percent} <=> $a->{percent} } @evolutions;
 294
 295         for my $e (@sorted_evolutions) {
 296                 printf "%+.1f%%", $e->{percent};
 297                 print " " . $e->{test};
 298                 print " " . format_times($e->{prevr}, $e->{prevu}, $e->{prevs});
 299                 print " " . format_times($e->{r}, $e->{u}, $e->{s});
 300                 print " " . display_dir($e->{prevrev});
 301                 print " " . display_dir($e->{rev});
 302                 print "\n";
 303         }
 304 }
 305
 306 sub print_codespeed_results {
 307         my ($subsection) = @_;
 308
 309         my $project = "Git";
 310
 311         my $executable = `uname -s -m`;
 312         chomp $executable;
 313
 314         if ($subsection) {
 315                 $executable .= ", " . $subsection;
 316         }
 317
 318         my $environment;
 319         if ($reponame) {
 320                 $environment = $reponame;
 321         } elsif (exists $ENV{GIT_PERF_REPO_NAME} and $ENV{GIT_PERF_REPO_NAME} ne "") {
 322                 $environment = $ENV{GIT_PERF_REPO_NAME};
 323         } else {
 324                 $environment = `uname -r`;
 325                 chomp $environment;
 326         }
 327
 328         my @data;
 329
 330         for my $t (@subtests) {
 331                 for my $d (@dirs) {
 332                         my $commitid = $prefixes{$d};
 333                         $commitid =~ s/^build_//;
 334                         $commitid =~ s/\.$//;
 335                         my ($result_value, $u, $s) = get_times("$resultsdir/$prefixes{$d}$t.times");
 336
 337                         my %vals = (
 338                                 "commitid" => $commitid,
 339                                 "project" => $project,
 340                                 "branch" => $dirnames{$d},
 341                                 "executable" => $executable,
 342                                 "benchmark" => $shorttests{$t} . " " . read_descr("$resultsdir/$t.descr"),
 343                                 "environment" => $environment,
 344                                 "result_value" => $result_value,
 345                             );
 346                         push @data, \%vals;
 347                 }
 348         }
 349
 350         require JSON;
 351         print JSON::to_json(\@data, {utf8 => 1, pretty => 1, canonical => 1}), "\n";
 352 }
 353
 354 binmode STDOUT, ":utf8" or die "PANIC on binmode: $!";
 355
 356 if ($codespeed) {
 357         print_codespeed_results($subsection);
 358 } elsif (defined $sortby) {
 359         print_sorted_results($sortby);
 360 } else {
 361         print_default_results();
 362 }