in reply to Re^2: Question on Regex
in thread Question on Regex

FYI:

#!/usr/bin/perl

use strict;
use warnings;
use Benchmark qw ( :hireswallclock cmpthese timethese );

our $string = qq (.co.uk/Jobs/Company-Sector/C8A6446X4PND86M9WYJ/Trade
+wind/?APath=2.21.0.0.0);

sub karlgoethebier {
    our $string;
    $string =~ m/.+\/.+\/.+\/.+\/(.+)\/.+/;
    return $1;
}

sub athanasius {
    our $string;
    return (split '/', $string)[4];
}

my $results = timethese (-10, {
        'karlgoethebier'   => 'karlgoethebier',
        'athanasius'       => 'athanasius',    
   });

cmpthese($results);

__END__

Karls-Mac-mini:Desktop karl$ ./tradewind.pl 
Benchmark: running athanasius, karlgoethebier for at least 10 CPU seco
+nds...
athanasius: 10.4769 wallclock secs (10.47 usr +  0.00 sys = 10.47 CPU)
+ @ 627362.46/s (n=6568485)
karlgoethebier: 10.4287 wallclock secs (10.42 usr +  0.00 sys = 10.42 
+CPU) @ 105188.77/s (n=1096067)
                   Rate karlgoethebier     athanasius
karlgoethebier 105189/s             --           -83%
athanasius     627362/s           496%             --

[download]

Regards, Karl

«The Crux of the Biscuit is the Apostrophe»

Replies are listed 'Best First'.
Re^4: Question on Regex
by Athanasius (Archbishop) on Nov 19, 2012 at 03:39 UTC

    Which shows that sub athanasius is up to 5 times faster than sub karlgoethebier. Even easier to see when supplying a positive COUNT value to timethese:

    #! perl
use strict;
use warnings;
use Benchmark qw( :hireswallclock cmpthese timethese );

my $string = ".co.uk/Jobs/Company-Sector/C8A6446X4PND86M9WYJ/Tradewind
+/?APath=2.21.0.0.0";

cmpthese(
            timethese
            (
                1_000_000,
                {
                    'karlgoethebier' =>
                    sub { $string =~ m/.+\/.+\/.+\/.+\/(.+)\/.+/; retu
+rn $1; },

                    'athanasius'     =>
                    sub { return (split '/', $string)[4] },
                }
            )
        );

    [download]

    Output:

    13:09 >perl 390_SoPW.pl
Benchmark: timing 1000000 iterations of athanasius, karlgoethebier...
athanasius: 5.19894 wallclock secs ( 5.15 usr +  0.00 sys =  5.15 CPU)
+ @ 194250.19/s (n=1000000)
karlgoethebier: 20.2485 wallclock secs (20.08 usr +  0.00 sys = 20.08 
+CPU) @ 49808.24/s (n=1000000)
                   Rate karlgoethebier     athanasius
karlgoethebier  49808/s             --           -74%
athanasius     194250/s           290%             --

13:16 >

    [download]

    Not really surprising, since regexen with quantifiers can be expensive:

    Avoid regular expressions with many quantifiers.... Such patterns can result in exponentially slow backtracking behavior unless the quantified subpatterns match on their first “pass”.
    — The Camel Book, 4th Edition, p. 693.

    So, what happens if we limit the backtracking?

    #! perl
use strict;
use warnings;
use Benchmark qw( :hireswallclock cmpthese timethese );

my $string = ".co.uk/Jobs/Company-Sector/C8A6446X4PND86M9WYJ/Tradewind
+/?APath=2.21.0.0.0";

cmpthese(
            timethese
            (
                1_000_000,
                {
                    'karlgoethebier'  =>
                    sub { $string =~ m/.+\/.+\/.+\/.+\/(.+)\/.+/; retu
+rn $1; },

                    'karlgoethebier2' =>
                    sub { $string =~ m/.+?\/.+?\/.+?\/.+?\/(.+?)\/.+/;
+ return $1; },

                    'athanasius'      =>
                    sub { return (split '/', $string)[4] },
                }
            )
        );

    [download]

    Result:

    13:28 >perl 390_SoPW.pl
Benchmark: timing 1000000 iterations of athanasius, karlgoethebier, ka
+rlgoethebier2...
athanasius: 4.91799 wallclock secs ( 4.88 usr +  0.00 sys =  4.88 CPU)
+ @ 204792.14/s (n=1000000)
karlgoethebier: 20.1721 wallclock secs (20.05 usr +  0.00 sys = 20.05 
+CPU) @ 49885.26/s (n=1000000)
karlgoethebier2: 2.55908 wallclock secs ( 2.53 usr +  0.00 sys =  2.53
+ CPU) @ 395569.62/s (n=1000000)
                    Rate  karlgoethebier      athanasius karlgoethebie
+r2
karlgoethebier   49885/s              --            -76%            -8
+7%
athanasius      204792/s            311%              --            -4
+8%
karlgoethebier2 395570/s            693%             93%              
+--

13:29 >perl 390_SoPW.pl

    [download]

    The regex is now significantly faster than split-with-subscript. Interesting!

    Athanasius <°(((>< contra mundum

[reply]
[d/l]
[select]

      Thats's nice! It's not a good habit to be too greedy. Regards, Karl

      «The Crux of the Biscuit is the Apostrophe»

[reply]

        Hello, one important thing i learned in the short time i'm on PM is: there is no reason to be ashamed to ask something that i don't know or understand. So i must confess that i have a problem to interpret the output of Benchmark in the right way. I didn't use this module very much yet.

        I know when i use cmpthese, the results are sorted from slow to fast. When i say $count = -10, my code runs for 10 wall clock seconds.

        Then, in the rate column i can see the amount of iterations per second for each of the subs that i benchmarked - in our (first) case:

        karlgoethebier 105189/s 
athanasius     627362/s

        [download]

        So i try:

        Karls-Mac-mini:Desktop karl $ perl -e 'printf ("%.0f\n", 627362/105189
+);'
6

        [download]

        You wrote:...Which shows that sub athanasius is up to 5 times faster than sub karlgoethebier. Perhaps i have a mental block at the moment or i miss something really essential, sorry.

        Thanks for advice and regards, Karl

        «The Crux of the Biscuit is the Apostrophe»

[reply]
[d/l]
[select]

In Section Seekers of Perl Wisdom