Mac Forum / Programming / Perl / November 2005

Just out of curiosity, why is this wishful thinking?

Thanks,
Boysenberry

boysenberrys.com | habitatlife.com | selfgnosis.com

The subroutines have to be known anyway. Unless, of course, you're  
going to let the eval() just crash...

When in doubt, benchmark it:

    #!/usr/bin/perl

    use strict;
    use warnings;

    use Benchmark qw(:all);

    my %dispatch = (
        'a' => \&a,
        'b' => \&b,
        'c' => \&c,
    );

    my $hashref = {
        'foo' => 1,
        'bar' => 2,
        'baz' => 3,
    };

    timethese(100000, {

        'Dispatch Table' => sub {
                for my $sub_name ('a', 'b', 'c', 'b', 'c', 'a', 'a',  
'c', 'b') {
                    $dispatch{$sub_name}->($hashref);
                }
            },

        'Symref' => sub {
                for my $sub_name ('a', 'b', 'c', 'b', 'c', 'a', 'a',  
'c', 'b') {
                    {
                        no strict 'refs';
                        &$sub_name($hashref);
                    }
                }
            },

        'Eval' => sub {
                for my $sub_name ('a', 'b', 'c', 'b', 'c', 'a', 'a',  
'c', 'b') {
                    eval "$sub_name(\$hashref)";
                }
            },

        });

    sub a {
        my ($hr) = @_;
        my $foo = "\t" . join(",", keys(%$hr)) . "\n";
    }

    sub b {
        my ($hr) = @_;
        my $foo = "\t" . join(",", keys(%$hr)) . "\n";
    }

    sub c {
        my ($hr) = @_;
        my $foo = "\t" . join(",", keys(%$hr)) . "\n";
    }

The results I get are:

Benchmark: timing 100000 iterations of Dispatch Table, Eval, Symref...
Dispatch Table: 17 wallclock secs (14.77 usr +  0.29 sys = 15.06 CPU)  
@ 6640.11/s (n=100000)
      Eval: 155 wallclock secs (139.45 usr +  3.23 sys = 142.68 CPU)  
@ 700.87/s (n=100000)
    Symref: 18 wallclock secs (17.49 usr +  0.35 sys = 17.84 CPU) @  
5605.38/s (n=100000)

The Eval results are no surprise - it has to compile the string for  
each iteration, which is a huge performance hit.

The symref approach has some overhead too, I suppose because of the  
extra scoping block for "no strict", but it's relatively small.  
Still, it's enough to make using symrefs a questionable idea.

I have to admit, I'm puzzled about why you'd call the dispatch table  
"over engineered". There's a difference in syntax when the sub is  
called, but that's trivial. The only substantial difference is the  
addition of the dispatch table itself, which isn't exactly a  
herculean effort. The result is both the cleanest and fastest of the  
three approaches.

sherm--

Cocoa programming in Perl: http://camelbones.sourceforge.net
Hire me! My resume: http://www.dot-app.org

As it turns out, I already had a list of allowed functions because I
didn't want to be eval'ing things from the text files and have it
error out (as I knew I would be building the functions over time and
I know I will always be missing some as there are potentially
thousands of them--each represents a Lego brick...).  So the dispatch
table worked fine.

Thanks!

--

Thanks,

James Reynolds
University of Utah
Student Computing Labs
james@scl.utah.edu
801-585-9811