Importing Scalar-Vec-Util-0.03.tar.gz

diff --git a/Changes b/Changes
index c8afa14cdb071375902d4ad209235d55594c8bb6..78cd7408f1785faa6f742bb3932fd65bca3445ef 100644 (file)
--- a/Changes
+++ b/Changes
@@ -1,5 +1,9 @@
 Revision history for Scalar-Vec-Util
 
+0.03    2008-06-01 12:30 UTC
+        + Chg : samples/bench.pl now compares with Bit::Vector when available.
+        + Doc : Show the benchmark.
+
 0.02    2008-05-13 16:40 UTC
         + Chg : Don't smoke this on 5.005 please.
         + Fix : File::Spec is a build dependency.

diff --git a/META.yml b/META.yml
index b2fb20003698de1771ccd5db73cb1b049d3ba2c9..27b65827704ec545fb5473cabd0013b84372f790 100644 (file)
--- a/META.yml
+++ b/META.yml
@@ -1,6 +1,6 @@
 --- #YAML:1.0
 name:                Scalar-Vec-Util
-version:             0.02
+version:             0.03
 abstract:            Utility routines for vec strings.
 license:             perl
 author:              

diff --git a/README b/README
index 69aa06bc0b036be56553a43c7ad6eaeb633381a2..ca8ba6bc9f083dde901208b6a0abdf73fe68dfe6 100644 (file)
--- a/README
+++ b/README
@@ -2,7 +2,7 @@ NAME
     Scalar::Vec::Util - Utility routines for vec strings.
 
 VERSION
-    Version 0.02
+    Version 0.03
 
 SYNOPSIS
         use Scalar::Vec::Util qw/vfill vcopy veq/;
@@ -56,6 +56,37 @@ EXPORT
     The constants "SVU_PP" and "SVU_SIZE" are also only exported on request.
     They are all exported by the tags ':consts' and ':all'.
 
+BENCHMARKS
+    The following timings were obtained by running the "samples/bench.pl"
+    script with perl 5.8.8 on a Core 2 Duo 2.66GHz machine. The "_pp"
+    entries are the pure Perl versions, while "_bv" are Bit::Vector
+    versions.
+
+    Filling bits at a given position :
+                          Rate vfill_pp vfill_bv    vfill
+            vfill_pp    80.3/s       --    -100%    -100%
+            vfill_bv 1053399/s 1312401%       --     -11%
+            vfill    1180792/s 1471129%      12%       --
+
+    Copying bits from a bit vector to a different one :
+                         Rate vcopy_pp vcopy_bv    vcopy
+            vcopy_pp    112/s       --    -100%    -100%
+            vcopy_bv  62599/s   55622%       --     -89%
+            vcopy    558491/s  497036%     792%       --
+
+    Moving bits in the same bit vector from a given position to a different
+    one :
+                         Rate vmove_pp vmove_bv    vmove
+            vmove_pp   64.8/s       --    -100%    -100%
+            vmove_bv  64742/s   99751%       --     -88%
+            vmove    547980/s  845043%     746%       --
+
+    Testing bit equality from different positions of different bit vectors :
+                       Rate  veq_pp  veq_bv     veq
+            veq_pp   92.7/s      --   -100%   -100%
+            veq_bv  32777/s  35241%      --    -94%
+            veq    505828/s 545300%   1443%      --
+
 CAVEATS
     Please report architectures where we can't use the alignment as the move
     unit. I'll add exceptions for them.

diff --git a/lib/Scalar/Vec/Util.pm b/lib/Scalar/Vec/Util.pm
index 3da4ad8cff1350a04b219de0c726ffbc0e7561c9..5d88b5ce07b5ace64ee37e116752f6b45e822bfc 100644 (file)
--- a/lib/Scalar/Vec/Util.pm
+++ b/lib/Scalar/Vec/Util.pm
@@ -11,13 +11,13 @@ Scalar::Vec::Util - Utility routines for vec strings.
 
 =head1 VERSION
 
-Version 0.02
+Version 0.03
 
 =cut
 
 our $VERSION;
 BEGIN {
- $VERSION = '0.02';
+ $VERSION = '0.03';
  eval {
   require XSLoader;
   XSLoader::load(__PACKAGE__, $VERSION);
@@ -133,6 +133,42 @@ our %EXPORT_TAGS    = (
 our @EXPORT_OK      = map { @$_ } values %EXPORT_TAGS;
 $EXPORT_TAGS{'all'} = [ @EXPORT_OK ];
 
+=head1 BENCHMARKS
+
+The following timings were obtained by running the C<samples/bench.pl> script with perl 5.8.8 on a Core 2 Duo 2.66GHz machine. The C<_pp> entries are the pure Perl versions, while C<_bv> are L<Bit::Vector> versions.
+
+=over 4
+
+=item Filling bits at a given position :
+
+                  Rate vfill_pp vfill_bv    vfill
+    vfill_pp    80.3/s       --    -100%    -100%
+    vfill_bv 1053399/s 1312401%       --     -11%
+    vfill    1180792/s 1471129%      12%       --
+
+=item Copying bits from a bit vector to a different one :
+
+                 Rate vcopy_pp vcopy_bv    vcopy
+    vcopy_pp    112/s       --    -100%    -100%
+    vcopy_bv  62599/s   55622%       --     -89%
+    vcopy    558491/s  497036%     792%       --
+
+=item Moving bits in the same bit vector from a given position to a different one :
+
+                 Rate vmove_pp vmove_bv    vmove
+    vmove_pp   64.8/s       --    -100%    -100%
+    vmove_bv  64742/s   99751%       --     -88%
+    vmove    547980/s  845043%     746%       --
+
+=item Testing bit equality from different positions of different bit vectors :
+
+               Rate  veq_pp  veq_bv     veq
+    veq_pp   92.7/s      --   -100%   -100%
+    veq_bv  32777/s  35241%      --    -94%
+    veq    505828/s 545300%   1443%      --
+
+=back
+
 =head1 CAVEATS
 
 Please report architectures where we can't use the alignment as the move unit. I'll add exceptions for them.

diff --git a/samples/bench.pl b/samples/bench.pl
index 3b736980239696e41143a76bc0117ca6d6dd31bb..9260606ea16cdb9df85d1135ef1430e8590604a3 100755 (executable)
--- a/samples/bench.pl
+++ b/samples/bench.pl
@@ -7,6 +7,8 @@ use Benchmark qw/cmpthese/;
 
 use lib qw{blib/arch blib/lib};
 use Scalar::Vec::Util qw/vfill vcopy veq/;
+my $has_bv = eval "use Bit::Vector; 1" || 0;
+print 'We ' . ('don\'t ' x !$has_bv) . "have Bit::Vector.\n";
 
 my $n = 100_000;
 my $i = 0;
@@ -18,10 +20,20 @@ sub inc {
  return $_[0];
 }
 
+sub len {
+ return $n - ($_[0] > $_[1] ? $_[0] : $_[1])
+}
+
+my ($bv1, $bv2, $bv3, $bv4);
+if ($has_bv) {
+ ($bv1, $bv2, $bv3, $bv4) = Bit::Vector->new($n, 4);
+}
+
 print "fill:\n";
 cmpthese -3, {
- vfill    => sub { vfill $x, inc($i), $n - $i, 1; },
- vfill_pp => sub { Scalar::Vec::Util::vfill_pp($x, inc($i), $n - $i, 1); }
+ vfill     => sub { vfill $x, inc($i), $n - $i, 1 },
+ vfill_pp  => sub { Scalar::Vec::Util::vfill_pp($x, inc($i), $n - $i, 1) },
+ (vfill_bv => sub { $bv1->Interval_Fill(inc($i), $n - 1) }) x $has_bv
 };
 
 $i = 0;
@@ -29,24 +41,40 @@ my $j = int $n / 2;
 my $y = '';
 print "\ncopy:\n";
 cmpthese -3, {
- vcopy    => sub { vcopy $x, inc($i), $y, inc($j), $n - ($i > $j ? $i : $j); },
- vcopy_pp => sub { Scalar::Vec::Util::vcopy_pp($x, inc($i), $y, inc($j), $n - ($i > $j ? $i : $j)); }
+ vcopy     => sub { vcopy $x, inc($i), $y, inc($j), len($i, $j) },
+ vcopy_pp  => sub { Scalar::Vec::Util::vcopy_pp($x, inc($i), $y, inc($j), len($i, $j)) },
+ (vcopy_bv => sub { $bv2->Interval_Copy($bv1, inc($j), inc($i), len($i, $j)) }) x $has_bv
 };
 
 $i = 0;
 $j = int $n / 2;
 print "\nmove:\n";
 cmpthese -3, {
- vcopy    => sub { vcopy $x, inc($i), $x, inc($j), $n - ($i > $j ? $i : $j); },
- vcopy_pp => sub { Scalar::Vec::Util::vcopy_pp($x, inc($i), $x, inc($j), $n - ($i > $j ? $i : $j)); }
+ vmove     => sub { vcopy $x, inc($i), $x, inc($j), len($i, $j) },
+ vmove_pp  => sub { Scalar::Vec::Util::vcopy_pp($x, inc($i), $x, inc($j), len($i, $j)) },
+ (vmove_bv => sub { $bv1->Interval_Copy($bv1, inc($j), inc($i), len($i, $j)) }) x $has_bv
 };
 
 $i = 0;
 $j = int $n / 2;
 vfill $x, 0, $n, 1;
 vfill $y, 0, $n, 1;
+if ($has_bv) {
+ $bv1->Fill();
+ $bv2->Fill();
+}
 print "\neq:\n";
 cmpthese -3, {
- veq    => sub { veq $x, inc($i), $y, inc($j), $n - ($i > $j ? $i : $j); },
- veq_pp => sub { Scalar::Vec::Util::veq_pp($x, inc($i), $y, inc($j), $n - ($i > $j ? $i : $j)); }
+ veq     => sub { veq $x, inc($i), $y, inc($j), len($i, $j) },
+ veq_pp  => sub { Scalar::Vec::Util::veq_pp($x, inc($i), $y, inc($j), len($i, $j)) },
+ (veq_bv => sub {
+   inc($i);
+   inc($j);
+   my $l = len($i, $j);
+   $bv3->Resize($l);
+   $bv3->Interval_Copy($bv1, 0, $i, $l);
+   $bv4->Resize($l);
+   $bv4->Interval_Copy($bv2, 0, $j, $l);
+   $bv3->equal($bv4);
+  }) x $has_bv
 };