The single-stack C++ parser is now the standard one.

[bison.git] / etc / bench.pl.in

diff --git a/etc/bench.pl.in b/etc/bench.pl.in
index 28003ea167a41ca547777a8cee1e49abe7df8958..91c35b997aa218feeb3b06c22128e9ca30a0c012 100755 (executable)
--- a/etc/bench.pl.in
+++ b/etc/bench.pl.in
@@ -23,13 +23,9 @@ bench.pl - perform benches on Bison parsers.
 
 =head1 SYNOPSIS
 
 
 =head1 SYNOPSIS
 

-  ./bench.pl
+  ./bench.pl [OPTIONS]... BENCHES

 
 

-=head1 OPTIONS
-
-=over 4
-
-=item B<-b>, B<--bench>=I<bench-name>
+=head1 BENCHES

 
 Specify the set of benches to run.  I<bench-name> should be one of:
 
 
 Specify the set of benches to run.  I<bench-name> should be one of:
 


@@ -50,24 +46,36 @@ Test the use of variants instead of union in the C++ parser.
 
 =back
 
 
 =back
 

+=head1 OPTIONS
+

 =item B<-c>, B<--cflags>=I<flags>
 
 =item B<-c>, B<--cflags>=I<flags>
 

-Flags to pass to the C or C++ compiler.
+Flags to pass to the C or C++ compiler.  Defaults to -O2.
+
+=item B<-h>, B<--help>
+
+Display this message and exit succesfully.  The more verbose, the more
+details.

 
 =item B<-i>, B<--iterations>=I<integer>
 
 Say how many times a single test of the bench must be run.  If
 negative, specify the minimum number of CPU seconds to run.  Defaults
 
 =item B<-i>, B<--iterations>=I<integer>
 
 Say how many times a single test of the bench must be run.  If
 negative, specify the minimum number of CPU seconds to run.  Defaults

-to -3.
+to -1.
+
+=item B<-q>, B<--quiet>
+
+Decrease the verbosity level (defaults to 1).

 
 =item B<-v>, B<--verbose>
 
 
 =item B<-v>, B<--verbose>
 

-Raise the verbosity level.  Currently only affects B<--help>.
+Raise the verbosity level (defaults to 1).

 
 =back
 
 =cut
 
 
 =back
 
 =cut
 

+use strict;

 use IO::File;
 
 ##################################################################
 use IO::File;
 
 ##################################################################


@@ -76,6 +84,10 @@ use IO::File;
 
 =over 4
 
 
 =over 4
 

+=item C<@bench>
+
+The list of benches to run.
+

 =item C<$bison>
 
 The Bison program to use to compile the grammar.
 =item C<$bison>
 
 The Bison program to use to compile the grammar.


@@ -107,9 +119,9 @@ Verbosity level.
 my $bison = $ENV{'BISON'} || '@abs_top_builddir@/tests/bison';
 my $cc = $ENV{'CC'} || 'gcc';
 my $cxx = $ENV{'CXX'} || 'g++';
 my $bison = $ENV{'BISON'} || '@abs_top_builddir@/tests/bison';
 my $cc = $ENV{'CC'} || 'gcc';
 my $cxx = $ENV{'CXX'} || 'g++';

-my $cflags = '';
-my $iterations = -3;
-my $verbose = 0;
+my $cflags = '-O2';
+my $iterations = -1;
+my $verbose = 1;

 
 =head1 FUNCTIONS
 
 
 =head1 FUNCTIONS
 


@@ -128,30 +140,27 @@ sub verbose($$)
     if $level <= $verbose;
 }
 
     if $level <= $verbose;
 }
 

+
+######################################################################
+

 =item C<directives($bench, @directive)>
 
 Format the list of directives for Bison for bench named C<$bench>.
 
 =item C<directives($bench, @directive)>
 
 Format the list of directives for Bison for bench named C<$bench>.
 

-The special fake C<%variant> directive requests the use of
-Boost.Variants instead of a regular union.  So don't pass it, it is
-not a valid directive.
-

 =cut
 
 sub directives($@)
 {
   my ($bench, @directive) = @_;
   my $res = "/* Directives for bench `$bench'. */\n";
 =cut
 
 sub directives($@)
 {
   my ($bench, @directive) = @_;
   my $res = "/* Directives for bench `$bench'. */\n";

-  for my $d (@directive)
-    {
-      $res .= $d . "\n"
-        unless $d eq '%variant';
-    }
+  $res .= join ("\n", @directive) . "\n";

   $res .= "/* End of directives for bench `$bench'. */\n";
   return $res;
 }
 
   $res .= "/* End of directives for bench `$bench'. */\n";
   return $res;
 }
 

-=item C<triangular_grammar ($base, $max, @directive)>
+######################################################################
+
+=item C<generate_grammar_triangular ($base, $max, @directive)>

 
 Create a large triangular grammar which looks like :
 
 
 Create a large triangular grammar which looks like :
 


@@ -177,7 +186,7 @@ The created parser is self contained: it includes its scanner, and
 source of input.
 =cut
 
 source of input.
 =cut
 

-sub triangular_grammar ($$$)
+sub generate_grammar_triangular ($$@)

 {
   my ($base, $max, @directive) = @_;
   my $directives = directives ($base, @directive);
 {
   my ($base, $max, @directive) = @_;
   my $directives = directives ($base, @directive);


@@ -288,7 +297,8 @@ sub calc_input ($$)
 }
 
 ##################################################################
 }
 
 ##################################################################

-=item C<calc_grammar ($base, $max, @directive)>
+
+=item C<generate_grammar_calc ($base, $max, @directive)>

 
 Generate a Bison file F<$base.y> for a calculator parser in C.  Pass
 the additional Bison C<@directive>.  C<$max> is ignored, but left to
 
 Generate a Bison file F<$base.y> for a calculator parser in C.  Pass
 the additional Bison C<@directive>.  C<$max> is ignored, but left to


@@ -296,7 +306,7 @@ have the same interface as C<triangular_grammar>.
 
 =cut
 
 
 =cut
 

-sub calc_grammar ($$$)
+sub generate_grammar_calc ($$@)

 {
   my ($base, $max, @directive) = @_;
   my $directives = directives ($base, @directive);
 {
   my ($base, $max, @directive) = @_;
   my $directives = directives ($base, @directive);


@@ -498,18 +508,18 @@ EOF
 
 ##################################################################
 
 
 ##################################################################
 

-=item C<variant_grammar ($base, $max, @directive)>
+=item C<generate_grammar_variant ($base, $max, @directive)>

 
 Generate a Bison file F<$base.y> that uses, or not, the Boost.Variants
 depending on the C<@directive>.
 
 =cut
 
 
 Generate a Bison file F<$base.y> that uses, or not, the Boost.Variants
 depending on the C<@directive>.
 
 =cut
 

-sub variant_grammar ($$$)
+sub generate_grammar_variant ($$@)

 {
   my ($base, $max, @directive) = @_;
   my $directives = directives ($base, @directive);
 {
   my ($base, $max, @directive) = @_;
   my $directives = directives ($base, @directive);

-  my $variant = grep { $_ eq '%variant' } @directive;
+  my $variant = grep { $_ eq '%define variant' } @directive;

 
   my $out = new IO::File ">$base.y"
     or die;
 
   my $out = new IO::File ">$base.y"
     or die;


@@ -532,7 +542,7 @@ $directives
 // Prototype of the yylex function providing subsequent tokens.
 static yy::parser::token_type yylex(yy::parser::semantic_type* yylval);
 
 // Prototype of the yylex function providing subsequent tokens.
 static yy::parser::token_type yylex(yy::parser::semantic_type* yylval);
 

-#define STAGE_MAX    ($max * 10)
+#define STAGE_MAX    ($max * 10) // max = $max

 #define USE_VARIANTS $variant
 #if USE_VARIANTS
 # define IF_VARIANTS(True, False) True
 #define USE_VARIANTS $variant
 #if USE_VARIANTS
 # define IF_VARIANTS(True, False) True


@@ -545,7 +555,6 @@ EOF
   if ($variant)
     {
       print $out <<'EOF';
   if ($variant)
     {
       print $out <<'EOF';

-%code variant {int,std::string}

 %token <std::string> TEXT
 %token <int> NUMBER
 %printer { std::cerr << "Number: " << $$; } <int>
 %token <std::string> TEXT
 %token <int> NUMBER
 %printer { std::cerr << "Number: " << $$; } <int>


@@ -572,7 +581,7 @@ EOF
     }
   else
     {
     }
   else
     {

-      # Not using Boost variants.
+      # Not using Bison variants.

       print $out <<'EOF';
 %union {int ival; std::string* sval;}
 %token <sval> TEXT
       print $out <<'EOF';
 %union {int ival; std::string* sval;}
 %token <sval> TEXT


@@ -644,6 +653,43 @@ EOF
 
 ##################################################################
 
 
 ##################################################################
 

+=item C<generate_grammar ($name, $base, @directive)>
+
+Generate F<$base.y> by calling C<&generate_grammar_$name>.
+
+=cut
+
+sub generate_grammar ($$@)
+{
+  my ($name, $base, @directive) = @_;
+  verbose 2, "Generating $base.y\n";
+  my %generator =
+    (
+      "calc"       => \&generate_grammar_calc,
+      "triangular" => \&generate_grammar_triangular,
+      "variant"    => \&generate_grammar_variant,
+    );
+  &{$generator{$name}}($base, 200, @directive);
+}
+
+##################################################################
+
+=item C<run ($command)>
+
+Run, possibly verbosely, the shell C<$command>.
+
+=cut
+
+sub run ($)
+{
+  my ($command) = @_;
+  verbose 2, "$command\n";
+  system ("$command") == 0
+    or die "$command failed";
+}
+
+##################################################################
+

 =item C<compile ($base)>
 
 Compile C<$base.y> to an executable C, Using the C or C++ compiler
 =item C<compile ($base)>
 
 Compile C<$base.y> to an executable C, Using the C or C++ compiler


@@ -659,12 +705,12 @@ sub compile ($)
 
   my $compiler = $language eq 'C++' ? $cxx : $cc;
 
 
   my $compiler = $language eq 'C++' ? $cxx : $cc;
 

-  system ("$bison $base.y -o $base.c") == 0
-    or die;
-  system ("$compiler -o $base $cflags $base.c") == 0
-    or die;
+  run "$bison $base.y -o $base.c";
+  run "$compiler -o $base $cflags $base.c";

 }
 
 }
 

+######################################################################
+

 =item C<bench_grammar ($gram, %bench)>
 
 Generate benches for C<$gram>.  C<$gram> should be C<calc> or
 =item C<bench_grammar ($gram, %bench)>
 
 Generate benches for C<$gram>.  C<$gram> should be C<calc> or


@@ -690,10 +736,7 @@ sub bench_grammar ($%)
   my %size;
   while (my ($name, $directives) = each %test)
     {
   my %size;
   while (my ($name, $directives) = each %test)
     {

-      verbose 1, "Generating $name\n";
-      # Call the Bison input file generator.
-      my $generator = "$gram" . "_grammar";
-      &$generator ($name, 200, @$directives);
+      generate_grammar ($gram, $name, @$directives);

       # Compile the executable.
       compile ($name);
       $bench{$name} = "system ('./$name');";
       # Compile the executable.
       compile ($name);
       $bench{$name} = "system ('./$name');";


@@ -709,26 +752,29 @@ sub bench_grammar ($%)
   # shows only wallclock and the two children times.  'auto' (the
   # default) will act as 'all' unless the children times are both
   # zero, in which case it acts as 'noc'.  'none' prevents output.
   # shows only wallclock and the two children times.  'auto' (the
   # default) will act as 'all' unless the children times are both
   # zero, in which case it acts as 'noc'.  'none' prevents output.

-  verbose 1, "Running the benches for $gram\n";
+  verbose 2, "Running the benches for $gram\n";

   my $res = timethese ($iterations, \%bench, 'nop');
 
   # Output the speed result.
   cmpthese ($res, 'nop');
 
   # Display the sizes.
   my $res = timethese ($iterations, \%bench, 'nop');
 
   # Output the speed result.
   cmpthese ($res, 'nop');
 
   # Display the sizes.

-  print "Sizes:\n";
+  print "Sizes (decreasing):\n";

   my $width = 10;
   for my $bench (keys %size)
     {
       $width = length $bench
         if $width < length $bench;
     }
   my $width = 10;
   for my $bench (keys %size)
     {
       $width = length $bench
         if $width < length $bench;
     }

-  for my $bench (keys %size)
+  # Benches sorted by decreasing size.
+  my @benches_per_size = sort {$size{$b} <=> $size{$a}} keys %size;
+  for my $bench (@benches_per_size)

     {
     {

-      printf "%${width}s: %5dkB\n", $bench, int ($size{$bench} / 1024);
+      printf "%${width}s: %5.2fkB\n", $bench, $size{$bench} / 1024;

     }
 }
 
     }
 }
 

+######################################################################

 
 =item C<bench_push_parser ()>
 
 
 =item C<bench_push_parser ()>
 


@@ -751,6 +797,8 @@ sub bench_push_parser ()
     );
 }
 
     );
 }
 

+######################################################################
+

 =item C<bench_variant_parser ()>
 
 Bench the C++ lalr1.cc parser using Boost.Variants or %union.
 =item C<bench_variant_parser ()>
 
 Bench the C++ lalr1.cc parser using Boost.Variants or %union.


@@ -762,16 +810,19 @@ sub bench_variant_parser ()
   bench_grammar
     ('variant',
      (
   bench_grammar
     ('variant',
      (

-      "f-union"         => ['%skeleton "lalr1-fusion.cc"'],
-      "f-uni-deb"   => ['%skeleton "lalr1-fusion.cc"', '%debug'],
-      "f-var"       => ['%skeleton "lalr1-fusion.cc"', '%variant'],
-      "f-var-deb" => ['%skeleton "lalr1-fusion.cc"', '%debug', '%variant'],
-      "f-var-dtr"       => ['%skeleton "lalr1-fusion.cc"', '%variant', "%code {\n#define VARIANT_DESTROY\n}"],
-      "f-var-deb-dtr" => ['%skeleton "lalr1-fusion.cc"', '%debug', '%variant', "%code {\n#define VARIANT_DESTROY\n}"],
+      "f-union"         => ['%skeleton "lalr1.cc"'],
+      "f-uni-deb"   => ['%skeleton "lalr1.cc"', '%debug'],
+      "f-var"       => ['%skeleton "lalr1.cc"', '%define variant'],
+      "f-var-deb" => ['%skeleton "lalr1.cc"', '%debug', '%define variant'],
+      "f-var-dtr"       => ['%skeleton "lalr1.cc"', '%define variant', "%code {\n#define VARIANT_DESTROY\n}"],
+      "f-var-deb-dtr" => ['%skeleton "lalr1.cc"', '%debug', '%define variant', "%code {\n#define VARIANT_DESTROY\n}"],
+      "f-var-deb-dtr-ass" => ['%skeleton "lalr1.cc"', '%debug', '%define variant', "%code {\n#define VARIANT_DESTROY\n}", "%define assert"],

      )
     );
 }
 
      )
     );
 }
 

+######################################################################
+

 =item C<bench_fusion_parser ()>
 
 Bench the C++ lalr1.cc parser using Boost.Variants or %union.
 =item C<bench_fusion_parser ()>
 
 Bench the C++ lalr1.cc parser using Boost.Variants or %union.


@@ -783,8 +834,8 @@ sub bench_fusion_parser ()
   bench_grammar
     ('variant',
      (
   bench_grammar
     ('variant',
      (

-      "split"         => [],
-      "fused"         => ['%skeleton "lalr1-fusion.cc"'],
+      "split"         => ['%skeleton "lalr1-split.cc"'],
+      "fused"         => ['%skeleton "lalr1.cc"'],

      )
     );
 }
      )
     );
 }


@@ -802,14 +853,16 @@ sub help ($)
                -output  => \*STDOUT });
 }
 
                -output  => \*STDOUT });
 }
 

+######################################################################
+

 sub getopt ()
 {
   use Getopt::Long;
 sub getopt ()
 {
   use Getopt::Long;

-  %option = (
-    "b|bench=s"      => \$bench,
+  my %option = (

     "c|cflags=s"     => \$cflags,
     "h|help"         => sub { help ($verbose) },
     "i|iterations=i" => \$iterations,
     "c|cflags=s"     => \$cflags,
     "h|help"         => sub { help ($verbose) },
     "i|iterations=i" => \$iterations,

+    "q|quiet"        => sub { --$verbose },

     "v|verbose"      => sub { ++$verbose },
     );
   Getopt::Long::Configure ("bundling", "pass_through");
     "v|verbose"      => sub { ++$verbose },
     );
   Getopt::Long::Configure ("bundling", "pass_through");


@@ -825,9 +878,13 @@ verbose 1, "Using cc=$cc.\n";
 verbose 1, "Using cxx=$cxx.\n";
 verbose 1, "Using cflags=$cflags.\n";
 
 verbose 1, "Using cxx=$cxx.\n";
 verbose 1, "Using cflags=$cflags.\n";
 

-bench_fusion_parser()  if $bench eq "fusion";
-bench_push_parser()    if $bench eq "push";
-bench_variant_parser() if $bench eq "variant";
+for my $b (@ARGV)
+{
+  verbose 1, "Running benchmark $b.\n";
+  bench_fusion_parser()  if $b eq "fusion";
+  bench_push_parser()    if $b eq "push";
+  bench_variant_parser() if $b eq "variant";
+}

 
 ### Setup "GNU" style for perl-mode and cperl-mode.
 ## Local Variables:
 
 ### Setup "GNU" style for perl-mode and cperl-mode.
 ## Local Variables: