use strict;                                                                     
use Benchmark 'cmpthese';                                                       
use Bit::Vector;                                                                
                                                                                
my @array = (!1) x 1_000_000;                                                   
my $vec = Bit::Vector->new(1_000_000);                                          
                                                                                
# Perl optimiert nicht für Methodenaufrufe (s. Benchmark unten)                 
# Daher müssen wir das machen:                                                  
*test = $vec->can('bit_test');

# Die XOR-Weiche bleibe hier unberuecksichtigt
# Der gesuchte Kompromiss kann sie gerne beinhalten
my ($start,$end) = (0,999_999);
cmpthese(100, {

      # über Array-Slice iterieren:
      slice => sub { my $sum; $sum += $_ ? 1 : -1 for @array[$start..$end]; },

      # vorher in ein eigenes Array kopieren, denn darüber wird schneller iteriert
      array => sub {
                   my @array = @array[$start .. $end];
                   my $sum; $sum += $_ ? 1 : -1 for @array;
               },

      # Müssten wir stets über das ganze @array laufen, gäbs also weder @start noch @end:
      theor => sub { my $sum; $sum += $_ ? 1 : -1 for @array; },

      # Subroutinenaufruf an Bit::Vector, d.h. gecachter Methodenaufruf
      bitvr => sub {
                   my $sum;
                   for ( my $i = $start; $i <= $end; $i++ ) {
                       $sum += test($vec,$i) ? 1 : -1;
                   }
               },

      # ungecacht:
      bitvm => sub {
                   my $sum;
                   for ( my $i = $start; $i <= $end; $i++ ) {
                       $sum += $vec->bit_test($i) ? 1 : -1;
                   }
               },
    }
)

# Dies ist die Ausgabe:
#==============================
        Rate bitvm bitvr array slice theor
bitvm 3.01/s    --  -14%  -43%  -73%  -84%
bitvr 3.51/s   17%    --  -34%  -68%  -81%
array 5.29/s   76%   51%    --  -52%  -72%
slice 11.1/s  269%  217%  110%    --  -41%
theor 18.8/s  524%  435%  255%   69%    --