2

我有一个希望并行化的 perl 脚本。

它由一个while超过 11000 行的循环和另一个while3400 行的循环组成，这使得它非常慢。

open (FILE1, "File1.txt") or die "Can't open File1";
open (OUT, ">Outfile.txt");

while (<FILE1>)
{ 
 my @data=split (/ /, $_);
 my $RS=1;
 open (FILE2, "File2.txt") or die "Can't open File2";
 while (<FILE2>)
 { 
  my @value=split (/ /, $_);
  if ($data[$RS] == 1) {print OUT $value[1];$RS++;}
  elsif ($data[$RS] == 2) {print OUT $value[2];$RS++;}
  elsif ($data[$RS] == 0) {print OUT $value[3];$RS++;}
 }
 close FILE2;

}

我正在寻找一种方法来对每一行执行相当于 qsub 的操作，File1这样我就可以发送 3440 个工作。有什么建议么？如果可能的话，我想留在 perl 上。我试图将此代码插入到 bash 脚本中，但我真的不明白如何在另一种语言中插入一种语言。

MyFile1包含一个 ID 列表，列中包含信息。然后每列与File2. 我希望能够同时为多个 ID 运行第二个循环，而不是一个接一个。

File1
ID     RS_10    RS_15    RS_30
23     1        0        1
34     2        2        0
45     1        1        0
23     0        0        2
10     2        1        1


File2
RS_10 A B C
RS_15 D E F
RS_30 G H I
4

1 回答 1

5

优化的第一条规则是不要做得太早（即在不分析代码的情况下过早地得出结论）。

第二条规则可能是指缓存。

你的File2不是很大。我会说我们将它加载到内存中。这具有以下优点：

  • 我们只做一次解析。
  • 该文件不是很大，因此空间不是什么大问题。
  • 我们可以创建一个使查找变得非常简单的数据结构。

关于第一点：您将每一行拆分三千多次。这些周期本来可以更好地度过。

关于第三点：您似乎进行了索引转换：

1 → 1, 2 → 2, 0 → 3

代替使用 if/elsif 开关（线性复杂度）测试所有值，我们可以使用一个数组来进行这种转换（恒定时间查找）：

my @conversion = (3, 1, 2);
...;
print OUT $value[$conversion[$data[$RS++]]];

如果这个索引转换是恒定的，我们可以在解析时只做一次File2。这看起来像

use strict; use warnings;
use autodie; # automatic error handling

my @file2;
{
  open my $file2, "<", "File2.txt";
  while (<$file2>) {
    my (undef, @vals) = split;

    # do the reordering. This is equivalent to @vals = @vals[2, 0, 1];
    unshift @vals, pop @vals;

    push @file2, \@vals;
  }
}

现在我们可以继续迭代File1. 从现在开始打印相应的条目File2看起来像

open my $file1, "<", "File1.txt";
<$file1>; # remove header
while (<$file1>) {
  my ($id, @indices) = split;
  print $id, map $file2[$_][$indices[$_]], 0 .. $#indices;
  # but I guess you'd want some separator in between
  # If so, set the $, variable
}

这个算法仍然是二次的（这map只是一个for变相的循环），但这应该有一个更好的常数因子。给定您的示例输入，上述代码的输出是

23 A F G
34 B E I
45 A D I
23 C F H
10 B D G

（与$, = " "; $\ = "\n"）。

从这往哪儿走

最后一步（循环通过 File1）可以并行化，但这不太可能有太大帮助：IO 很慢，线程之间的通信很昂贵（IPC 更是如此），并且输出将是随机顺序的。我们可以生成一堆工人，并在队列中传递未解析的行：

use threads; # should be 1st module to be loaded
use Thread::Queue;
use constant NUM_THREADS => 4; # number of cores

# parse the File2 data here

my $queue = Thread::Queue->new;
my @threads = map threads->new(\&worker), 1 .. NUM_THREADS;

# enqueue data
$queue->enqueue($_) while <$file1>;
# end the queue
$queue->enqueue((undef) x NUM_THREADS); # $queue->end in never versions

# wait for threads to complete
$_->join for @threads;

sub worker {
  while(defined(my $_ = $queue->dequeue)) {
    my ($id, @indices) = split;
    print $id, map $file2[$_][$indices[$_]], 0 .. $#indices;
  }
}

请注意，这会将 复制@file2到所有线程中。有趣的事实：对于示例数据，这个线程解决方案大约需要 4 倍的时间。这主要是线程创建的开销，因此这对您的数据来说不是什么问题。

在任何情况下，分析您的代码以查看您可以最有效地优化的地方。我推荐优秀的Devel::NYTProf。例如，对于我使用这些非常有限的数据运行的非线程测试，autodie和朋友暗示的开销比实际处理花费的时间更多。对你来说，最昂贵的线路可能是

  print $id, map $file2[$_][$indices[$_]], 0 .. $#indices;

但是在 Perl 中我们无能为力。

于 2013-07-24T19:29:25.063 回答