[ 目测题 ] 大神们, 小伙伴们 : why B.pl slow than A.pl

pitonas

A.pl:

1. #!/usr/bin/perl
   
2. my $seq = 'CATTCATTCTCTAACAGCAGTAATATTAATAATTTTCAT';
   
3. $seq x= 200000;
   
4. 
   
5. my @tr = qw[
   
6.   K N K N   T T T T   R S R S   I I M I
   
7.   Q H Q H   P P P P   R R R R   L L L L
   
8.   E D E D   A A A A   G G G G   V V V V
   
9.   _ Y _ Y   S S S S   _ C W C   L F L F
   
10. ];
    
11. 
    
12. my @I = (
    
13.     [   [ 0, 1, 2, 3     ],
    
14.         [ 4, 5, 6, 7     ],
    
15.         [ 8, 9, 10, 11   ],
    
16.         [ 12, 13, 14, 15 ]
    
17.     ],
    
18.     [
    
19.         [ 16, 17, 18, 19 ],
    
20.         [ 20, 21, 22, 23 ],
    
21.         [ 24, 25, 26, 27 ],
    
22.         [ 28, 29, 30, 31 ]
    
23.     ],
    
24.     [
    
25.         [ 32, 33, 34, 35 ],
    
26.         [ 36, 37, 38, 39 ],
    
27.         [ 40, 41, 42, 43 ],
    
28.         [ 44, 45, 46, 47 ]
    
29.     ],
    
30.     [
    
31.         [ 48, 49, 50, 51 ],
    
32.         [ 52, 53, 54, 55 ],
    
33.         [ 56, 57, 58, 59 ],
    
34.         [ 60, 61, 62, 63 ]
    
35.     ]
    
36. );
    
37. 
    
38.    
    
39. $seq =~ y/ACGT/0123/;
    
40. my @dna = split //, $seq;
    
41. splice @dna, @dna - @dna % 3;
    
42. print @tr[ TR(@dna) ];
    
43. 
    
44. 
    
45. sub TR {
    
46.     map { $I[shift][shift][shift] } 0 .. $#_ / 3;
    
47. }
    

复制代码

B.pl:

1. #!/usr/bin/perl
   
2. my $seq = 'CATTCATTCTCTAACAGCAGTAATATTAATAATTTTCAT';
   
3. $seq x= 200000;
   
4. 
   
5. my @tr = (
   
6.     [ [qw/K N K N/], [qw/T T T T/], [qw/R S R S/], [qw/I I M I/] ],
   
7.     [ [qw/Q H Q H/], [qw/P P P P/], [qw/R R R R/], [qw/L L L L/] ],
   
8.     [ [qw/E D E D/], [qw/A A A A/], [qw/G G G G/], [qw/V V V V/] ],
   
9.     [ [qw/_ Y _ Y/], [qw/S S S S/], [qw/_ C W C/], [qw/L F L F/] ],
   
10. );
    
11.    
    
12. $seq =~ y/ACGT/0123/;
    
13. my @dna = split //, $seq;
    
14. splice @dna, @dna - @dna % 3;
    
15. print TR(@dna);
    
16. 
    
17. sub TR {
    
18.     map { $tr[shift][shift][shift] } 0 .. $#_ / 3;
    
19. }
    

复制代码

A.pl: 2 operations
print @tr[ TR(@dna) ];
1: TR(@dna)
2: @tr[ ... ];

B.pl: only 1 operation
print TR(@dna);
1: TR(@dna)

A.pl:: @tr , B.pl:: @I    ===>  array: 4 x 4 x 4

why ??? {:2_170:}  
B.pl slow than A.pl ?

yinyuemi

回复 1# pitonas


    我猜原因是，b.pl的@tr，每调用一次，编译一次，而a.pl的@i只用了头开始的那次，你试着在b.pl中函数部分传入@tr的引用，看看速度如何

pitonas

IF: b.pl的@tr，每调用一次，编译一次
then: a.pl的@I，也每调用一次，编译一次


qw 这是一种语法糖 ? {:2_179:}
B2.pl 仍然比 A.pl 慢 ~ {:2_170:}

B2.pl:

1. #!/usr/bin/perl
   
2. my $seq = 'CATTCATTCTCTAACAGCAGTAATATTAATAATTTTCAT';
   
3. $seq x= 200000;
   
4. 
   
5. my @tr = (
   
6.     [
   
7.         [ 'K', 'N', 'K', 'N' ],
   
8.         [ 'T', 'T', 'T', 'T' ],
   
9.         [ 'R', 'S', 'R', 'S' ],
   
10.         [ 'I', 'I', 'M', 'I' ]
    
11.     ],
    
12.     [
    
13.         [ 'Q', 'H', 'Q', 'H' ],
    
14.         [ 'P', 'P', 'P', 'P' ],
    
15.         [ 'R', 'R', 'R', 'R' ],
    
16.         [ 'L', 'L', 'L', 'L' ]
    
17.     ],
    
18.     [
    
19.         [ 'E', 'D', 'E', 'D' ],
    
20.         [ 'A', 'A', 'A', 'A' ],
    
21.         [ 'G', 'G', 'G', 'G' ],
    
22.         [ 'V', 'V', 'V', 'V' ]
    
23.     ],
    
24.     [
    
25.         [ '_', 'Y', '_', 'Y' ],
    
26.         [ 'S', 'S', 'S', 'S' ],
    
27.         [ '_', 'C', 'W', 'C' ],
    
28.         [ 'L', 'F', 'L', 'F' ]
    
29.     ],
    
30. 
    
31. );
    
32. 
    
33. $seq =~ y/ACGT/0123/;
    
34. my @dna = split //, $seq;
    
35. splice @dna, @dna - @dna % 3;
    
36. print TR(@dna);
    
37. 
    
38. sub TR {
    
39.     map { $tr[shift][shift][shift] } 0 .. $#_ / 3;
    
40. }
    

复制代码

回复 2# yinyuemi


   

yinyuemi

回复 3# pitonas


   

perldoc -f print
Because print takes a LIST, anything in the LIST is evaluated in list context, including
               any subroutines whose return lists you pass to "print".  Be
               careful not to follow the print keyword with a left parenthesis
               unless you want the corresponding right parenthesis to
               terminate the arguments to the print; put parentheses around
               all arguments (or interpose a "+", but that doesn't look as
               good).

如果把两个script里的print去掉，速度几乎相差不大，b.pl似乎更快，但是加了print之后，b.pl速度下降，原因应该是quote部分的第一句，print 需要evaluate subroutine RT返回的所有值，而 a.pl中print 后面接的是@符，所以不需要check，打印@tr的值。

pitonas

my test: b.pl 慢 ~

a.pl
my @tmp = @tr[ TR(@dna) ];
print scalar @tmp;

b.pl
my @tmp = TR(@dna);
print scalar @tmp;


坐在巷口的那对男女, 一动也不动的呆在那里, 所以我顺便询问了.
他们说:
是 array 的关系,

A.pl: @I 数字数组
B.pl: @tr 字符串数组 ( index 操作慢了 )

所以，在这样的时候，总有一种力量它让我内牛满面
这确实是

1. 
   
2. my @s = qw/ A B C D E /;
   
3. my @n = 1 .. 5;
   
4. 
   
5. # ----------------------
   
6. my @n2 = (@n) x 2000000;    # fast
   
7. my @s2 = (@s) x 2000000;    # slow
   
8. 
   
9. # ----------------------
   
10. my @indexn = @n2[@n2];      # fast
    
11. my @indexs = @s2[@n2];      # slow
    
12. 
    

复制代码

回复 4# yinyuemi


   

yinyuemi

回复 5# pitonas


   
    已经超出我的理解范围，不知哪位大神出来解释一下？

zhlong8

回复 5# pitonas


    复制一个字符串要比复制一个整数多一个malloc

zhlong8

5.20 后字符串有了 copy on write 差别应该就微乎其微了

测了下，5.20还是差好多

yinyuemi

zhlong8 发表于 2014-08-10 19:17
回复 5# pitonas

果然是底层的原因，话说版主这个是从哪儿查的呢？

zhlong8

回复 9# yinyuemi


    现在CPAN跳到 metacpan 那篇 illguts 找不到了，你要愿意入坑的话 perl 源码里面有 sv.h, perldoc 有 http://perldoc.perl.org/index-internals.html