0

好奇是否有人知道（或可以轻松测试）引用然后取消引用数组所需的时间。

my @foo = (0..1500000);     # (~1.5M nodes).
join('',@{\@foo});          # any noticeable time difference vs join('',@foo) ?

这显然没有正当理由，但我遇到了不合理的代码:)

4

3 回答 3

7

我执行的类似测试的基准给出了每个 deref 大约 10 纳秒的结果。您发布的代码中只有 deref，所以我们谈论的是 0.000,000,010 秒的差异。

呸，差别太小了，我什至无法确定哪个更快！

Benchmark: running array, array_ref for at least 3 CPU seconds...
     array:  3 wallclock secs ( 3.04 usr +  0.02 sys =  3.06 CPU) @ 11.12/s (n=34)
 array_ref:  3 wallclock secs ( 3.13 usr +  0.00 sys =  3.13 CPU) @ 11.48/s (n=36)

Benchmark: running array, array_ref for at least 3 CPU seconds...
     array:  3 wallclock secs ( 3.06 usr +  0.03 sys =  3.09 CPU) @ 11.33/s (n=35)
 array_ref:  3 wallclock secs ( 3.12 usr +  0.05 sys =  3.17 CPU) @ 11.37/s (n=36)

Benchmark: running array, array_ref for at least 3 CPU seconds...
     array:  3 wallclock secs ( 3.06 usr +  0.00 sys =  3.06 CPU) @ 11.45/s (n=35)
 array_ref:  3 wallclock secs ( 3.18 usr +  0.00 sys =  3.18 CPU) @ 11.31/s (n=36)

Benchmark: running array, array_ref for at least 3 CPU seconds...
     array:  3 wallclock secs ( 3.09 usr +  0.00 sys =  3.09 CPU) @ 11.66/s (n=36)
 array_ref:  3 wallclock secs ( 3.17 usr +  0.00 sys =  3.17 CPU) @ 11.37/s (n=36)

数组快 50% 的时间，数组 ref 快 50% 的时间。

use strict;
use warnings;

use Benchmark qw( timethese );

my %tests = (
   array_ref => 'my $x = join("", @$foo);',
   array     => 'my $x = join("", @foo);',
);

$_ = 'use strict; use warnings; our $foo; our @foo; ' . $_
   for values(%tests);

our @foo = 1..1_500_000;
our $foo = \@foo;

timethese(-3, \%tests);

这是比您发布的测试更好的测试。您发布的唯一一个花费不到 1% 的时间做您想要测试的事情。

但同样，差异是如此之小，以至于无法测量。有时数组 ref 出现得更快，有时数组出现得更快。

Actual speed is actually 1000x larger than indicated.
Benchmark: running array, array_ref for at least 3 CPU seconds...
     array:  3 wallclock secs ( 3.09 usr +  0.00 sys =  3.09 CPU) @ 1015.54/s (n=3136)
 array_ref:  3 wallclock secs ( 3.24 usr +  0.00 sys =  3.24 CPU) @ 1040.99/s (n=3378)

Actual speed is actually 1000x larger than indicated.
Benchmark: running array, array_ref for at least 3 CPU seconds...
     array:  3 wallclock secs ( 3.25 usr +  0.00 sys =  3.25 CPU) @ 1011.09/s (n=3281)
 array_ref:  3 wallclock secs ( 3.07 usr +  0.00 sys =  3.07 CPU) @ 1022.13/s (n=3141)

Actual speed is actually 1000x larger than indicated.
Benchmark: running array, array_ref for at least 3 CPU seconds...
     array:  3 wallclock secs ( 3.29 usr +  0.00 sys =  3.29 CPU) @ 1020.96/s (n=3361)
 array_ref:  3 wallclock secs ( 3.20 usr +  0.00 sys =  3.20 CPU) @ 1016.26/s (n=3250)

Actual speed is actually 1000x larger than indicated.
Benchmark: running array, array_ref for at least 3 CPU seconds...
     array:  3 wallclock secs ( 3.07 usr +  0.00 sys =  3.07 CPU) @ 1053.03/s (n=3237)
 array_ref:  4 wallclock secs ( 3.23 usr +  0.00 sys =  3.23 CPU) @ 1006.50/s (n=3250)

同样，array 在 50% 的时间内更快，array ref 在 50% 的时间内更快。

use strict;
use warnings;

use Benchmark qw( timethese );

my %tests = (
   array_ref => 'my $x = join("", @$foo);',
   array     => 'my $x = join("", @foo);',
);

$_ = 'use strict; use warnings; our $foo; our @foo; for (1..1000) { '.$_.' }'
   for values(%tests);

our @foo = 1..15;
our $foo = \@foo;

print("Actual speed is actually 1000x larger than indicated.\n");
timethese(-3, \%tests);
于 2012-04-11T22:10:16.777 回答
6

一个简单的基准测试表明，将 1 到 1,500,000 的整数连接成一个字符串的不同方法之间没有明显的区别（除了错误的方法——下面没有显示）。

我确实想知道为什么需要创建这样一个字符串，但后来我想知道很多。

#!/usr/bin/env perl

use strict; use warnings;
use Benchmark qw( cmpthese );

my @nodes = (1 .. 1_500_000);

cmpthese -5, {
    derefref_join => sub {
        my $str = join('', @{ \@nodes });
    },
    plain_join => sub {
        my $str = join('', @nodes);
    },
    interpolate => sub {
        local $" = '';
        my $str = "@nodes";
    },
};

输出：

                速率插值 deref_join plain_join
插值 4.76/s -- -3% -3%
derefref_join 4.89/s 3% -- -1%
plain_join 4.92/s 4% 1% --
C:\temp> perl -v

这是为 MSWin32-x86-multi-thread 构建的 perl 5，版本 14，subversion 2 (v5.14.2)
ActiveState http://www.ActiveState.com 提供的二进制版本 1402 [295342]
建于 2011 年 10 月 7 日 15:49:44

Intel Core2 Duo T2300E@1.66Ghz，2GB 内存。
于 2012-04-11T22:15:18.220 回答
-1

显然，由于处理器速度的不同，每个主机都会有所不同。

衡量这一点的一种方法是使用该time函数来记录时间。然后创建并执行一个包含数十万个解引用操作的循环（因为测量单个解引用将非常快，您将无法测量它。）然后，再次记录时间。减去次数并除以循环的次数。从中减去在没有取消引用的情况下通过循环所需的时间。一点点数学，你就有了。

于 2012-04-11T21:21:35.047 回答