1  #! /usr/bin/perl
  2  
  3  use strict;
  4  use warnings;
  5  
  6  my $debug = defined $ENV{RLDEBUG};
  7  
  8  my %analysis = ();
  9  my $order = 0;
 10  
 11  while (<STDIN>) {
 12      if (m|
 13                  Doing
 14                  (?: \s+ (?<inputsize>\d+) \s+ bits)?
 15                  \s+ (?<algo>[-A-Za-z0-9]+)
 16                  \s+ (?<op>\w+) \s+ ops
 17                  \s+ for \s+ (?<seconds>\d+)s
 18                  (?:\s+ on \s+ (?<blocksize>\d+) \s+ byte \s+ blocks)?
 19                  (?:\s+ with \s+ (?<keysize>\d+) \s+ bit \s+ key)?
 20                  :
 21                  \s+ (?<numops>\d+) \s+ ops
 22                  \s+ in \s+ (?<time>\d+\.\d+)s
 23           |x) {
 24          my $row = $+{algo};
 25          $row .= sprintf(" %5d bits", $+{inputsize}) if $+{inputsize};
 26          $row .= sprintf(" <keysize=%d>", $+{keysize}) if $+{keysize};
 27  
 28          # Use an order number to ensure algorithms and rows are ordered
 29          # like they come from the input.
 30          $analysis{$+{algo}}->{order} //= ++$order;
 31          $analysis{$+{algo}}->{rows}->{$row} //= ++$order;
 32  
 33          if($+{blocksize}) {
 34              my $column = "bytes/s @ $+{blocksize}";
 35              $analysis{$+{algo}}->{columns}->{$column} = 1;
 36              $analysis{$+{algo}}->{data}->{"$row / $column"}
 37              = sprintf "%.2fk", ( 0.00 + $+{numops} ) * $+{blocksize} / $+{time} / 1000;
 38          } else {
 39              my $column1 = "s/$+{op}";
 40              my $column2 = "$+{op}/s";
 41              $analysis{$+{algo}}->{columns}->{$column1} = 1;
 42              $analysis{$+{algo}}->{data}->{"$row / $column1"}
 43              = sprintf "%f", ( 0.00 + $+{time} ) / $+{numops};
 44              $analysis{$+{algo}}->{columns}->{$column2} = 1;
 45              $analysis{$+{algo}}->{data}->{"$row / $column2"}
 46              = sprintf "%.1f", ( 0.00 + $+{numops} ) / $+{time};
 47          }
 48      }
 49  }
 50  
 51  my %sort_numbers = (
 52      # Relative positions for everything regarding known -assoc operations
 53      's/genkey'                  => -100,
 54      's/enc'                     => -90,
 55      's/dec'                     => -80,
 56      's/sign'                    => -70,
 57      's/verify'                  => -60,
 58      's/encap'                   => -50,
 59      's/decap'                   => -40,
 60  
 61      'genkey/s'                  => -10,
 62      'enc/s'                     => -9,
 63      'dec/s'                     => -8,
 64      'sign/s'                    => -7,
 65      'verify/s'                  => -6,
 66      'encap/s'                   => -5,
 67      'decap/s'                   => -4,
 68      'bytes/s @ (?<blocksize>\d+)' => sub { 0.0 + $+{blocksize} }
 69  );
 70  sub colsort {
 71      my $find_number = sub {
 72          my $column = shift;
 73          foreach my $k (keys %sort_numbers) {
 74              if ($column =~ m|^${k}$|) {
 75                  return
 76                      ref $sort_numbers{$k} eq 'CODE'
 77                      ? $sort_numbers{$k}->()
 78                      : $sort_numbers{$k};
 79              }
 80          }
 81          return undef;
 82      };
 83      my $a_n = $find_number->($a);
 84      my $b_n = $find_number->($b);
 85      print STDERR "DEBUG[colsort]: '$a' => $a_n\n" if $debug;
 86      print STDERR "DEBUG[colsort]: '$b' => $b_n\n" if $debug;
 87      return $a_n <=> $b_n;
 88  }
 89  
 90  sub algosort {
 91      $analysis{$a}->{order} <=> $analysis{$b}->{order}
 92  }
 93  
 94  sub rowsort {
 95      my $algo = shift @_;
 96      $analysis{$algo}->{rows}->{$a} <=> $analysis{$algo}->{rows}->{$b}
 97  }
 98  
 99  foreach my $algo (sort { algosort } keys %analysis) {
100      my @rows = ( sort { rowsort($algo) } keys %{$analysis{$algo}->{rows}} );
101      my @columns = ( "", sort { colsort } keys %{$analysis{$algo}->{columns}} );
102      my @column_max_size = ( map { length($_) } @columns );
103  
104      # Figure out sizes, so we get nicely aligned columns
105      foreach my $row (@rows) {
106          {
107              # column 0 is all about row names
108              my $data = $row;
109              if (length($data) > $column_max_size[0]) {
110                  $column_max_size[0] = length($data);
111              }
112          }
113          foreach my $i (1..$#columns) {
114              my $column = $columns[$i];
115              my $dataname = "$row / $column";
116              my $data = $analysis{$algo}->{data}->{$dataname} // "";
117              if (length($data) > $column_max_size[$i]) {
118                  $column_max_size[$i] = length($data);
119              }
120          }
121      }
122  
123      print "\n";
124  
125      # Print header line
126      foreach my $i (0..$#columns) {
127          my $minsize = $column_max_size[$i];
128          if ($i == 0) {
129              # Left adjusted
130              printf "%-${minsize}s", $columns[$i];
131          } else {
132              # Space, then right adjusted
133              printf "  %${minsize}s", $columns[$i];
134          }
135      }
136      print "\n";
137  
138      # Print the data line
139      foreach my $row (@rows) {
140          {
141              my $minsize = $column_max_size[0];
142              # Left adjusted
143              printf "%-${minsize}s", $row;
144          }
145          foreach my $i (1..$#columns) {
146              my $column = $columns[$i];
147              my $dataname = "$row / $column";
148              my $data = $analysis{$algo}->{data}->{$dataname} // "";
149              my $minsize = $column_max_size[$i];
150              # Space, then right adjusted
151              printf "  %${minsize}s", $data;
152          }
153          print "\n";
154      }
155  }