=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:
=back
+=head1 OPTIONS
+
=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
-to -3.
+to -1.
+
+=item B<-q>, B<--quiet>
+
+Decrease the verbosity level (defaults to 1).
=item B<-v>, B<--verbose>
-Raise the verbosity level. Currently only affects B<--help>.
+Raise the verbosity level (defaults to 1).
=back
=cut
+use strict;
use IO::File;
##################################################################
=over 4
+=item C<@bench>
+
+The list of benches to run.
+
=item C<$bison>
The Bison program to use to compile the grammar.
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
if $level <= $verbose;
}
+
+######################################################################
+
=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";
- 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;
}
-=item C<triangular_grammar ($base, $max, @directive)>
+######################################################################
+
+=item C<generate_grammar_triangular ($base, $max, @directive)>
Create a large triangular grammar which looks like :
source of input.
=cut
-sub triangular_grammar ($$$)
+sub generate_grammar_triangular ($$@)
{
my ($base, $max, @directive) = @_;
my $directives = directives ($base, @directive);
}
##################################################################
-=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
=cut
-sub calc_grammar ($$$)
+sub generate_grammar_calc ($$@)
{
my ($base, $max, @directive) = @_;
my $directives = directives ($base, @directive);
##################################################################
-=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
-sub variant_grammar ($$$)
+sub generate_grammar_variant ($$@)
{
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;
// 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
if ($variant)
{
print $out <<'EOF';
-%code variant {int,std::string}
%token <std::string> TEXT
%token <int> NUMBER
%printer { std::cerr << "Number: " << $$; } <int>
}
else
{
- # Not using Boost variants.
+ # Not using Bison variants.
print $out <<'EOF';
%union {int ival; std::string* sval;}
%token <sval> TEXT
##################################################################
+=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
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
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');";
# 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.
- print "Sizes:\n";
+ print "Sizes (decreasing):\n";
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_variant_parser ()>
Bench the C++ lalr1.cc parser using Boost.Variants or %union.
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.
bench_grammar
('variant',
(
- "split" => [],
- "fused" => ['%skeleton "lalr1-fusion.cc"'],
+ "split" => ['%skeleton "lalr1-split.cc"'],
+ "fused" => ['%skeleton "lalr1.cc"'],
)
);
}
-output => \*STDOUT });
}
+######################################################################
+
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,
+ "q|quiet" => sub { --$verbose },
"v|verbose" => sub { ++$verbose },
);
Getopt::Long::Configure ("bundling", "pass_through");
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:
projects / bison.git / blobdiff