perl - perl脚本的并行化

Question

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

它由一个 while 循环组成，在另一个 3400 行的 while 循环中包含超过 11000 行，这使得它非常慢。

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;

}

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

我的 File1 包含 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

Answer 1

优化的第一条规则是不要过早进行优化(即在不分析代码的情况下跳到过早的结论)。

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

您的 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 更是如此)，并且输出会顺序随机。我们可以派生一堆 worker ，并在队列中传递未解析的行:

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 和 friend 隐含的开销比实际处理所用的时间更多。对你来说，最昂贵的线路可能是

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

但在 Perl 中我们无能为力。