Perl6：处理非常大的文件的最佳方法是什么？

Question

上周我决定尝试 Perl6 并开始重新实现我的一个程序。我不得不说，Perl6 非常容易进行对象编程，这是我在 Perl5 中非常痛苦的一个方面。

我的程序必须读取和存储大文件，例如全基因组（高达 3 Gb 或更多，请参见下面的示例 1）或制表数据。

代码的第一个版本是通过逐行迭代以 Perl5 方式制作的 ("genome.fa".IO.lines)。对于正确的执行时间来说，它非常缓慢且无法使用。

my class fasta {
  has Str $.file is required;
  has %!seq;

  submethod TWEAK() {
    my $id;
    my $s;

    for $!file.IO.lines -> $line {
      if $line ~~ /^\>/ {
        say $id;
        if $id.defined {
          %!seq{$id} = sequence.new(id => $id, seq => $s);
        }
        my $l = $line;
        $l ~~ s:g/^\>//;
        $id = $l;
        $s = "";
      }
      else {
        $s ~= $line;
      }
    }
    %!seq{$id} = sequence.new(id => $id, seq => $s);
  }
}


sub MAIN()
{
    my $f = fasta.new(file => "genome.fa");
}

因此，在使用了一些 RTFM 之后，我更改了对文件的 slurp，对 \n 进行了拆分，我用 for 循环对其进行了解析。这样我就设法在 2 分钟内加载了数据。好多了，但还不够。通过作弊，我的意思是通过删除最多 \n（示例 2），我将执行时间减少到 30 秒。很好，但不是完全满意，这种 fasta 格式不是最常用的。

my class fasta {
  has Str $.file is required;
  has %!seq;

  submethod TWEAK() {
    my $id;
    my $s;

    say "Slurping ...";
    my $f = $!file.IO.slurp;

    say "Spliting file ...";
    my @lines = $f.split(/\n/);

    say "Parsing lines ...";
    for @lines -> $line {
      if $line !~~ /^\>/ {
          $s ~= $line;
      }
      else {
        say $id;
        if $id.defined {
          %!seq{$id} = seq.new(id => $id, seq => $s);
        }
        $id = $line;
        $id ~~ s:g/^\>//;
        $s = "";
      }
    }
    %!seq{$id} = seq.new(id => $id, seq => $s);
  }
}

sub MAIN()
{
    my $f = fasta.new(file => "genome.fa");
}

所以再次使用 RTFM，我发现了语法的魔力。所以无论使用什么 fasta 格式，新版本和 45 秒的执行时间。不是最快的方法，但更优雅和稳定。

my grammar fastaGrammar {
  token TOP { <fasta>+ }

  token fasta   {<.ws><header><seq> }
  token header  { <sup><id>\n }
  token sup     { '>' }
  token id      { <[\d\w]>+ }
  token seq     { [<[ACGTNacgtn]>+\n]+ }

}

my class fastaActions {
  method TOP ($/){
    my @seqArray;

    for $<fasta> -> $f {
      @seqArray.push: seq.new(id => $f.<header><id>.made, seq => $f<seq>.made);
    }
    make @seqArray;
  }

  method fasta ($/) { make ~$/; }
  method id    ($/) { make ~$/; }
  method seq   ($/) { make $/.subst("\n", "", :g); }

}

my class fasta {
  has Str $.file is required;
  has %seq;

  submethod TWEAK() {

    say "=> Slurping ...";
    my $f = $!file.IO.slurp;

    say "=> Grammaring ...";
    my @seqArray = fastaGrammar.parse($f, actions => fastaActions).made;

    say "=> Storing data ...";
    for @seqArray -> $s {
      %!seq{$s.id} = $s;
    }
  }
}

sub MAIN()
{
    my $f = fasta.new(file => "genome.fa");
}

我认为我找到了处理这类大文件的好方法，但性能仍然低于 Perl5。

作为 Perl6 的新手，我很想知道是否有更好的方法来处理大数据，或者 Perl6 的实现是否存在一些限制？

作为Perl6的新手，请教两个问题：

是否还有我不知道或尚未知道的其他 Perl6 机制记录在案，用于存储文件中的大量数据（比如我的基因组）？
我是否达到了当前版本的最大性能 Perl6 ？

感谢阅读！

Fasta 示例 1：

>2L
CGACAATGCACGACAGAGGAAGCAGAACAGATATTTAGATTGCCTCTCATTTTCTCTCCCATATTATAGGGAGAAATATG
ATCGCGTATGCGAGAGTAGTGCCAACATATTGTGCTCTTTGATTTTTTGGCAACCCAAAATGGTGGCGGATGAACGAGAT
...
>3R
CGACAATGCACGACAGAGGAAGCAGAACAGATATTTAGATTGCCTCTCATTTTCTCTCCCATATTATAGGGAGAAATATG
ATCGCGTATGCGAGAGTAGTGCCAACATATTGTGCTCTTTGATTTTTTGGCAACCCAAAATGGTGGCGGATGAACGAGAT
...

Fasta 示例 2：

>2L
GACAATGCACGACAGAGGAAGCAGAACAGATATTTAGATTGCCTCTCAT...            
>3R
TAGGGAGAAATATGATCGCGTATGCGAGAGTAGTGCCAACATATTGTGCT...

编辑我应用了@Christoph 和@timotimo 的建议并使用代码进行测试：

my class fasta {
  has Str $.file is required;
  has %!seq;

  submethod TWEAK() {
    say "=> Slurping / Parsing / Storing ...";
    %!seq = slurp($!file, :enc<latin1>).split('>').skip(1).map: {
  .head => seq.new(id => .head, seq => .skip(1).join) given .split("\n").cache;
    }
  }
}


sub MAIN()
{
    my $f = fasta.new(file => "genome.fa");
}

程序在2.7秒内完成，太棒了！我还在小麦基因组 (10 Gb) 上尝试了此代码。它在 35.2 秒内完成。 Perl6 终于没那么慢了！

非常感谢您的帮助！

Answer 1

一个简单的改进是使用 latin1 等固定宽度编码来加速字符解码，但我不确定这会有多大帮助。

就 Rakudo 的 regex/grammar 引擎而言，我发现它非常慢，因此可能确实有必要采用更底层的方法。

我没有做任何基准测试，但我首先尝试的是这样的：

my %seqs = slurp('genome.fa', :enc<latin1>).split('>')[1..*].map: {
    .[0] => .[1..*].join given .split("\n");
}

由于 Perl6 标准库是在 Perl6 本身中实现的，因此有时可以通过避免它来提高性能，以命令式风格编写代码，例如：

my %seqs;
my $data = slurp('genome.fa', :enc<latin1>);
my $pos = 0;
loop {
    $pos = $data.index('>', $pos) // last;

    my $ks = $pos + 1;
    my $ke = $data.index("\n", $ks);

    my $ss = $ke + 1;
    my $se = $data.index('>', $ss) // $data.chars;

    my @lines;

    $pos = $ss;
    while $pos < $se {
        my $end = $data.index("\n", $pos);
        @lines.push($data.substr($pos..^$end));
        $pos = $end + 1
    }

    %seqs{$data.substr($ks..^$ke)} = @lines.join;
}

但是，如果所使用的标准库部分在性能上有所改善，这实际上可能会使事情变得更糟。在这种情况下，下一步要做的是添加低级类型注释，例如 str 和 int，并将对 .index 等例程的调用替换为 NQP builtins，例如nqp::index.

如果还是太慢，那说明你运气不好，需要切换语言，例如使用 Inline::Perl5 调用 Perl5 或使用 NativeCall.

调用 C

请注意，@timotimo 已经完成了一些性能测量并写了 an article 关于它。

如果我的简短版本是基线，命令式版本将性能提高 2.4 倍。

他实际上通过将其重写为

设法从简短版本中挤出了 3 倍的改进

my %seqs = slurp('genome.fa', :enc<latin-1>).split('>').skip(1).map: {
    .head => .skip(1).join given .split("\n").cache;
}

最后，使用 NQP 内置函数重写命令式版本将速度提高了 17 倍，但考虑到潜在的可移植性问题，通常不鼓励编写此类代码，但如果您确实需要该级别的性能，现在可能是必要的:

use nqp;

my Mu $seqs := nqp::hash();
my str $data = slurp('genome.fa', :enc<latin1>);
my int $pos = 0;

my str @lines;

loop {
    $pos = nqp::index($data, '>', $pos);

    last if $pos < 0;

    my int $ks = $pos + 1;
    my int $ke = nqp::index($data, "\n", $ks);

    my int $ss = $ke + 1;
    my int $se = nqp::index($data ,'>', $ss);

    if $se < 0 {
        $se = nqp::chars($data);
    }

    $pos = $ss;
    my int $end;

    while $pos < $se {
        $end = nqp::index($data, "\n", $pos);
        nqp::push_s(@lines, nqp::substr($data, $pos, $end - $pos));
        $pos = $end + 1
    }

    nqp::bindkey($seqs, nqp::substr($data, $ks, $ke - $ks), nqp::join("", @lines));
    nqp::setelems(@lines, 0);
}

Perl6：处理非常大的文件的最佳方法是什么？

Perl6 : What is the best way for dealing with very big files?

performance

grammar

parsing

fasta

raku