performance - 是否可以优化这部分的性能

Question

我在 Perl 中的性能有问题。这是代码： http: //pastebin.com/jpmhv395

它可能在其他地方也有问题，但主要问题在第 336 行：anagram_hash 方法似乎被经常调用。该方法实际上是在不同的模块中，这里是： http: //pastebin.com/5NRC4bs8

子例程的工作方式应该不同，具体取决于作为参数传递的是整数还是字符串。

子例程 'anagram_hash' 是否导致性能不佳，或者您是否看到任何其他可能导致性能下降的情况？如果可以，如何优化？

Answer 1

我想你可以制作一个 256 元素的查找表，所以你就这样做

$result += $lookup{$char};

代替

my $temp = ord($char);
$result += $temp**5;

但是您应该真正运行分析器以首先查看问题所在...这里。

编辑（jm666 和 ikegami） - 添加了基准示例。正如您通过观察 power_goodloop 和 lookup_goodloop 的结果所看到的那样，它们仅因使用取幂还是使用哈希查找而异，取幂要快得多。让你慢下来的是糟糕的循环。

use strict;
use warnings;
use feature qw( say );
use Benchmark qw(:all);

my @lookup = map { $_ ** 5 } 0..255;
my %lookup = map { chr($_) => $_ ** 5 } 0..255;

my $str = join '', map chr(rand(256)), 1..1000;

say "test of the result";
say anagram_hash1($str);
say anagram_hash2($str);
say anagram_hash3($str);
say anagram_hash4($str);
say anagram_hash5($str);
say "";    
cmpthese(-3, {
    'power_badloop'    => sub { anagram_hash1($str) },
    'hlookup_badloop'  => sub { anagram_hash2($str) },
    'power_goodloop'   => sub { anagram_hash3($str) },
    'hlookup_goodloop' => sub { anagram_hash4($str) },
    'alookup_goodloop' => sub { anagram_hash5($str) },
});


sub anagram_hash1 {
        my $result = 0;
        my $s      = shift;
        my $length = length($s);
        if ( $s =~ /[a-zA-Z]+/ ) {
                for ( my $i = 0 ; $i < $length ; $i++ ) {
                        my $char = substr( $s, $i, 1 );
                        my $temp = ord($char);
                        $result += $temp**5;
                }
        } elsif ( $s =~ /^[\d]+$/ ) {
                my $temp = int($s);
                $result += $temp**5;
        } else {
                die "Invalid parameter passed to method 'anagram_hash'\nExpected: String or Number\nPassed: $s";
        }
        return $result;
}
sub anagram_hash2 {
        my $result = 0;
        my $s      = shift;
        my $length = length($s);
        if ( $s =~ /[a-zA-Z]+/ ) {
                for ( my $i = 0 ; $i < $length ; $i++ ) {
                        my $char = substr( $s, $i, 1 );
                        $result += $lookup{$char};
                }
        } elsif ( $s =~ /^[\d]+$/ ) {
                my $temp = int($s);
                $result += $temp**5;
        } else {
                die "Invalid parameter passed to method 'anagram_hash'\nExpected: String or Number\nPassed: $s";
        }
        return $result;
}

sub anagram_hash3 {
        my $result = 0;
        my $s      = shift;
        if ( $s =~ /[a-zA-Z]/ ) {
                $result += $_ ** 5 for unpack "C*", $s;
        } elsif ( $s =~ /^[\d]+$/ ) {
                $result += int($s) ** 5;
        } else {
                die "Invalid parameter passed to method 'anagram_hash'\nExpected: String or Number\nPassed: $s";
        }
        return $result;
}

sub anagram_hash4 {
        my $result = 0;
        my $s      = shift;
        if ( $s =~ /[a-zA-Z]/ ) {
                $result += $lookup{$_} for unpack "(a)*", $s;
        } elsif ( $s =~ /^[\d]+$/ ) {
                $result += int($s) ** 5;
        } else {
                die "Invalid parameter passed to method 'anagram_hash'\nExpected: String or Number\nPassed: $s";
        }
        return $result;
}

sub anagram_hash5 {
        my $result = 0;
        my $s      = shift;
        if ( $s =~ /[a-zA-Z]/ ) {
                $result += $lookup[$_] for unpack "C*", $s;
        } elsif ( $s =~ /^[\d]+$/ ) {
                $result += int($s) ** 5;
        } else {
                die "Invalid parameter passed to method 'anagram_hash'\nExpected: String or Number\nPassed: $s";
        }
        return $result;
}

输出：

test of the result
171658778879381
171658778879381
171658778879381
171658778879381
171658778879381

                   Rate power_badloop hlookup_badloop hlookup_goodloop power_goodloop alookup_goodloop
power_badloop    2132/s            --            -25%             -35%           -71%             -74%
hlookup_badloop  2826/s           33%              --             -14%           -62%             -66%
hlookup_goodloop 3294/s           55%             17%               --           -56%             -60%
power_goodloop   7446/s          249%            163%             126%             --             -10%
alookup_goodloop 8298/s          289%            194%             152%            11%               --

所以，结果显示：

• 原始OP的代码是最慢的
• 第二个是 Mark 的解决方案（用哈希查找替换 ord/exp） - 因此，Mark 的解决方案比原始 OP 的代码更快。

最后，（像往常一样）Ikegami 提供了 3 个解决方案，这些解决方案比以前的任何一个都快得多。:)