Re^2: Counting the number of items returned by split without using a named array

[Anonymous Monk]

My bias goes towards either

$entries = @{[ split ]};

or

$entries = () = /\S+/g;

as "most elegant".
It's both sufficiently short, although I'm not sure which one is easier to understand for the uninitiated reader :)
Just out of curiosity (it doesnt really matter in my case):
which one would be the more (CPU- and memory-) efficient one?

I.

[BrowserUk]

C:\test>p1
our $s = join ' ', 'aa'..'zz';;
cmpthese -3, { 
    split => q[ $_=$s; my $n = @{[ split ]}; ], 
    regex => q[ $_=$s; my $n = () = /\S+/g;  ] 
};;
        Rate regex split
regex  546/s    --  -50%
split 1102/s  102%    --

Assuming I didn't goof on the benchmark split appears to be quicker.

[Anonymous Monk]

Strange
perhaps it depends on the length of the input string?
My attempt shows a different result
You seem to be under windows - so just for comparison:


$ cat a.pl; echo '-----------' ;echo;./a.pl 
#!/usr/local/bin/perl -w
           use Benchmark qw(:all) ;

our $s = join ' ', 'aa'..'zz';;
cmpthese( -3, { 
    split => q[ $_=$s; my $n = @{[ split ]}; ], 
    regex => q[ $_=$s; my $n = () = /\S+/g;  ] 
});

-----------

        Rate regex split
regex  981/s    --  -53%
split 2098/s  114%    --


Hm, now where's the big diff to the other Bench?
I.

[BrowserUk]

Hm, now where's the big diff to the other Bench?

Try switching warnings on in your first benchmark. It will probably explain the difference :)

[Anonymous Monk]

Argh... Link went wrong :( meant to link to the other benchmark above: http://www.perlmonks.org/?node_id=547169

[blazar]

Just out of curiosity (it doesnt really matter in my case): which one would be the more (CPU- and memory-) efficient one?

It hardly ever matters. As a wild guess I would say that since the former involves doing something and then undoing it and that something is taking a reference, it is more computationally intensive. In case of doubt

use Benchmark;

I may well (and happily!) prove wrong...

[Anonymous Monk]

As you wish (or not):


$ cat foo.pl ; echo "--------";echo; ./foo.pl 
#!/usr/bin/perl 
##################
use Benchmark qw(:all) ;

sub test1(){
$entries = @{[ split ]};
}

sub test2(){
$entries = () = /\S+/g;
}

$_="This is an example string with several words bla bla bla\n";
$count=1E+7;
timethis ($count, "test1()");
print "------------\n";
timethis ($count, "test2()");


--------

timethis 10000000: 13 wallclock secs (12.37 usr +  0.01 sys = 12.38 CP
+U) @ 807754.44/s (n=10000000)
------------
timethis 10000000:  7 wallclock secs ( 6.66 usr +  0.00 sys =  6.66 CP
+U) @ 1501501.50/s (n=10000000)

[blazar]

Adding use warnings; results in

Use of uninitialized value in split at foo.pl line 9.

Hmmm... adding (-l and) print $entries to both subs results in:

Use of uninitialized value in split at foo.pl line 9.
0
Use of uninitialized value in pattern match (m//) at foo.pl line 14.
0

Now,

#!/usr/bin/perl

use strict;
use warnings;
use Benchmark qw(:all :hireswallclock);

my $str="This is an example string with several words bla bla bla";

sub test1 () {
    local $_=$str;
    my $entries = @{[ split ]};
}

sub test2 () {
    local $_=$str;
    my $entries = () = /\S+/g;
}

cmpthese -10, {
    deref => \&test1,
    goatse => \&test2,
};

__END__

results in

          Rate goatse  deref
goatse 16325/s     --   -42%
deref  28017/s    72%     --