我读过几次unpack()比这更快substr(),特别是随着子串数量的增加.但是,这个基准建议不然.我的基准测试是否存在缺陷,或者是unpack()旧版Perl的保留所谓的性能优势？
use strict;
use warnings;
use Benchmark;
my ($data, $format_string, $n_substrings);
my %methods = (
unpack => sub { return unpack $format_string, $data },
substr => sub { return map {substr $data, $_, 1} 0 .. $n_substrings - 1 },
);
for my $exp (1 .. 5){
$n_substrings = 10 ** $exp;
print $n_substrings, "\n";
$format_string = 'a1' x $n_substrings;
$data = 9 x $n_substrings;
Benchmark::cmpthese -2, \%methods;
}
输出(在Windows上):
10
Rate unpack substr
unpack 131588/s -- -52%
substr 276802/s 110% --
100
Rate unpack substr
unpack 13660/s -- -57%
substr 31636/s 132% --
1000
Rate unpack substr
unpack 1027/s -- -68%
substr 3166/s 208% --
10000
Rate unpack substr
unpack 84.4/s -- -74%
substr 322/s 281% --
100000
Rate unpack substr
unpack 5.46/s -- -82%
substr 30.1/s 452% --
正如在一些答案中指出的那样,unpack()在Windows上做得不好.这是solaris机器上的输出 - 不是那么具有决定性,但substr()仍然赢得了比赛:
10
Rate unpack substr
unpack 202274/s -- -4%
substr 210818/s 4% --
100
Rate unpack substr
unpack 22015/s -- -9%
substr 24322/s 10% --
1000
Rate unpack substr
unpack 2259/s -- -9%
substr 2481/s 10% --
10000
Rate unpack substr
unpack 225/s -- -9%
substr 247/s 9% --
100000
Rate unpack substr
unpack 22.0/s -- -10%
substr 24.4/s 11% --
dlo*_*owe 19
事实上,你的基准是有缺陷的,真的,非常有趣的方式,但它归结为你真正比较的是解包与地图可以扔掉一个列表的相对效率,因为Benchmark :: cmpthese()正在执行void上下文中的函数.
你的substr出现在顶部的原因是pp_ctl.c pp_mapwhile()中的这行代码:
if (items && gimme != G_VOID) {
即perl的地图神奇地跳过一堆工作(即为地图的结果分配存储),如果它知道它是在虚拟上下文中被调用的话!
(我对Windows的预感与上面提到的其他内容相比,基于Windows的perl内存分配很糟糕,所以跳过分配是一个更大的节省 - 只是预感,但是,我没有一个Windows框可以玩但实际的解压缩实现是直接的C代码,并且不应该与其他窗口大不相同.)
我有三种不同的解决方案来解决这个问题并产生更公平的比较:
这是我的%方法版本,包含所有三个版本:
my %methods = (
unpack_assign => sub { my @foo = unpack $format_string, $data; return },
unpack_loop => sub { for my $foo (unpack $format_string, $data) { } },
unpack_return_ref => sub { return [ unpack $format_string, $data ] },
unpack_return_array => sub { return unpack $format_string, $data },
substr_assign => sub { my @foo = map {substr $data, $_, 1} 0 .. ($n_substrings - 1) },
substr_loop => sub { for my $foo ( map {substr $data, $_, 1} 0 .. ($n_substrings - 1)) { } },
substr_return_ref => sub { return [ map {substr $data, $_, 1} 0 .. ($n_substrings - 1) ] },
substr_return_array => sub { return map { substr $data, $_, 1} 0 .. ($n_substrings - 1) },
);
我的结果是:
$ perl -v
This is perl, v5.10.0 built for x86_64-linux-gnu-thread-multi
$ perl foo.pl
10
Rate substr_assign substr_return_ref substr_loop unpack_assign unpack_return_ref unpack_loop unpack_return_array substr_return_array
substr_assign 101915/s -- -20% -21% -28% -51% -51% -65% -69%
substr_return_ref 127224/s 25% -- -1% -10% -39% -39% -57% -62%
substr_loop 128484/s 26% 1% -- -9% -38% -39% -56% -61%
unpack_assign 141499/s 39% 11% 10% -- -32% -32% -52% -57%
unpack_return_ref 207144/s 103% 63% 61% 46% -- -1% -29% -37%
unpack_loop 209520/s 106% 65% 63% 48% 1% -- -28% -37%
unpack_return_array 292713/s 187% 130% 128% 107% 41% 40% -- -12%
substr_return_array 330827/s 225% 160% 157% 134% 60% 58% 13% --
100
Rate substr_assign substr_loop substr_return_ref unpack_assign unpack_return_ref unpack_loop unpack_return_array substr_return_array
substr_assign 11818/s -- -25% -25% -26% -53% -55% -63% -70%
substr_loop 15677/s 33% -- -0% -2% -38% -40% -51% -60%
substr_return_ref 15752/s 33% 0% -- -2% -37% -40% -51% -60%
unpack_assign 16061/s 36% 2% 2% -- -36% -39% -50% -59%
unpack_return_ref 25121/s 113% 60% 59% 56% -- -4% -22% -35%
unpack_loop 26188/s 122% 67% 66% 63% 4% -- -19% -33%
unpack_return_array 32310/s 173% 106% 105% 101% 29% 23% -- -17%
substr_return_array 38910/s 229% 148% 147% 142% 55% 49% 20% --
1000
Rate substr_assign substr_return_ref substr_loop unpack_assign unpack_return_ref unpack_loop unpack_return_array substr_return_array
substr_assign 1309/s -- -23% -25% -28% -52% -54% -62% -67%
substr_return_ref 1709/s 31% -- -3% -6% -38% -41% -51% -57%
substr_loop 1756/s 34% 3% -- -3% -36% -39% -49% -56%
unpack_assign 1815/s 39% 6% 3% -- -34% -37% -48% -55%
unpack_return_ref 2738/s 109% 60% 56% 51% -- -5% -21% -32%
unpack_loop 2873/s 120% 68% 64% 58% 5% -- -17% -28%
unpack_return_array 3470/s 165% 103% 98% 91% 27% 21% -- -14%
substr_return_array 4015/s 207% 135% 129% 121% 47% 40% 16% --
10000
Rate substr_assign substr_return_ref substr_loop unpack_assign unpack_return_ref unpack_loop unpack_return_array substr_return_array
substr_assign 131/s -- -23% -27% -28% -52% -55% -63% -67%
substr_return_ref 171/s 30% -- -5% -6% -38% -42% -52% -57%
substr_loop 179/s 37% 5% -- -1% -35% -39% -50% -55%
unpack_assign 181/s 38% 6% 1% -- -34% -38% -49% -55%
unpack_return_ref 274/s 109% 60% 53% 51% -- -6% -23% -32%
unpack_loop 293/s 123% 71% 63% 62% 7% -- -18% -27%
unpack_return_array 356/s 171% 108% 98% 96% 30% 21% -- -11%
substr_return_array 400/s 205% 134% 123% 121% 46% 37% 13% --
100000
Rate substr_assign substr_return_ref substr_loop unpack_assign unpack_return_ref unpack_loop unpack_return_array substr_return_array
substr_assign 13.0/s -- -22% -26% -29% -51% -55% -63% -67%
substr_return_ref 16.7/s 29% -- -5% -8% -37% -43% -52% -58%
substr_loop 17.6/s 36% 5% -- -3% -33% -40% -50% -56%
unpack_assign 18.2/s 40% 9% 3% -- -31% -37% -48% -54%
unpack_return_ref 26.4/s 103% 58% 50% 45% -- -9% -25% -34%
unpack_loop 29.1/s 124% 74% 65% 60% 10% -- -17% -27%
unpack_return_array 35.1/s 170% 110% 99% 93% 33% 20% -- -12%
substr_return_array 39.7/s 206% 137% 125% 118% 50% 36% 13% --
回到原来的问题:"unpack()比substr()更快吗？" 答:总是,对于这种类型的应用 - 除非你不关心返回值;)
测试没有缺陷,但它是偏斜的.如果您需要做的只是从字符串中提取一个相当简单的子字符串,那么substr会更好,但那就是它.例如,使用substr即使这个简单的任务也不容易完成:
$foo = '123foo456789bar89012';
my ($t1,$t2,$t3,$t4,$t5) = unpack("A3A3A6A3A5",$foo);
那就是你应该看到substr和unpack之间的巨大差异.
自从提出这个问题以来，我在各种条件下又进行了多次基准substr测试。unpack以下是我学到的一些东西：
不要以在 void 上下文中调用 Perl 函数的方式设置基准（就像我在最初的问题中所做的那样；请参阅 dlowe 的有用回复）。某些 Perl 函数在 void 上下文中调用时会进行优化（这些优化似乎因操作系统而异），可能会扭曲您的基准测试结果。
如果您的使用substr涉及循环（例如，迭代列位置列表），unpack
则总是更快。然而，在这种情况下，明显的缓慢substr是由于循环的开销，而不是循环substr本身。
如果只需要几个字段，
substr通常会更快或与 一样快unpack。
如果需要多个字段，则随着字段数量的增加，unpack同等数量的substr调用之间的头对头比较不会有太大变化：两种方法都会以相同的速度变慢。
结果可能因操作系统而异。在我的 Windows XP 机器上，unpack
每当需要多个字段时，就会有轻微的优势。在我工作场所的 Solaris 机器上，速度
substr总是更快，甚至可以进入数百个领域。
底线：无论字段数量如何，unpackvs.的性能都不是一个很大的问题。substr使用哪种方法可以产生最清晰的代码。然而，如果您发现自己substr在循环结构中使用，切换到unpack将导致显着的速度提升。