2

我正在尝试执行一个 perl 脚本来处理一个小的 12 x 2 文本文件（大约 260 字节）和一个大的 .bedgraph 文件（至少 1.3 MB 大小）。从这两个文件中，脚本输出一个新的床位图文件。

我已经在其他 3 个 .bedgraph 文件上运行了这个脚本，但我尝试在其余的文件上运行它，过程不断得到Killed。

.bedgraphperl 脚本在每个文件上运行平均需要大约 20 分钟。

我在本地机器上运行 perl 脚本（而不是从服务器上）。我使用的是 Linux OS Ubuntu 12.04 系统 64 位 4GB RAM。

为什么我的 perl 脚本执行不断被杀死，我该如何解决这个问题？

这是脚本：

# input file handle
open(my $sizes_fh, '<', 'S_lycopersicum_chromosomes.size') or die $!;

# output file handles
open(my $output, '+>', 'tendaysafterbreaker_output.bedgraph') or die $!;

my @array;

while(<$sizes_fh>){
    chomp;
    my ($chrom1, $size) = split(/\t/, $_);
    @array = (0) x $size;

    open(my $bedgraph_fh, '<', 'Solanum_lycopersicum_tendaysafterbreaker.bedgraph') or die $!;
    while(<$bedgraph_fh>){
        chomp;
        my ($chrom2, $start, $end, $FPKM) = split(/\t/, $_);

        if ($chrom1 eq $chrom2){
            for(my $i = $start; $i < $end; $i++){
                $array[$i] += $FPKM;
            }
        }
    }

    close $bedgraph_fh or warn $!;

    my ($last_start, $last_end) = 0;
    my $last_value = $array[0];

    for (my $i = 1; $i < $#array; $i++){
        my $curr_val = $array[$i];
        my $curr_pos = $i;

        # if the current value is not equal to the last value
        if ($curr_val != $last_value){
            my $last_value = $curr_val;
            print $output "$chrom1\t$last_start\t$last_end\t$last_value\n";
            $last_start = $last_end = $curr_pos;
        } else {
            $last_end = $i;
        }
    }
}

close $sizes_fh or warn $!;
4

3 回答 3

5

您正在尝试分配一个包含 90,000,000 个元素的数组。Perl，由于其灵活的类型和其他高级变量特性，为此使用的内存比您预期的要多得多。

在我的（Windows 7）机器上，一个只分配这样一个数组而什么都不做的程序占用了 3.5 GB 的 RAM。

有多种方法可以避免这种巨大的内存使用。这里有一对：

用于科学数据处理的PDL模块，旨在有效地将巨大的数字数组存储在内存中。不过，这将改变分配和使用数组的语法（并且它以各种其他方式与 Perl 的语法混为一谈）。

DBM::Deep是一个在文件中分配数据库的模块——然后允许您通过普通数组或散列访问该数据库：

use DBM::Deep;
my @array;
my $db = tie @array, "DBM::Deep", "array.db";

#Now you can use @array like a normal array, but it will be stored in a database.
于 2013-04-26T06:33:04.833 回答
2

如果您了解一点 C 语言，那么将数组操作卸载到低级代码中是非常简单的。使用 C 数组占用的空间更少，而且速度更快。但是，您会丢失诸如边界检查之类的好东西。这是 Inline::C 的实现：

use Inline 'C';
...;
__END__
__C__
// note: I don't know if your data contains only ints or doubles. Adjust types as needed
int array_len = -1; // last index
int *array = NULL;

void make_array(int size) {
  free(array);
  // if this fails, start checking return value of malloc for != NULL
  array = (int*) malloc(sizeof(int) * size);
  array_len = size - 1;
}

// returns false on bounds error
int array_increment(int start, int end, int fpkm) {
  if ((end - 1) > array_len) return 0;
  int i;
  for (i = start; i < end; i++) {
    array[i] += fpkm;
  }
  return 1;
}

// please check if this is actually equivalent to your code.
// I removed some unneccessary-looking variables.
void loop_over_array(char* chrom1) {
  int
    i,
    last_start = 0,
    last_end   = 0,
    last_value = array[0];
  for(i = 1; i < array_len; i++) { // are you sure not `i <= array_len`?
    if (array[i] != last_value) {
      last_value = array[i];
      // I don't know how to use Perl filehandles from C,
      // so just redirect the output on the command line
      printf("%s\t%d\t%d\t%d\n", chrom1, last_start, last_end, last_value);
      last_start = i;
    }
    last_end = i;
  }
}

void free_array {
  free(array);
}

最少的测试代码：

use Test::More;

make_array(15);
ok !array_increment(0, 16, 2);
make_array(95_000_000);
ok array_increment(0, 3, 1);
ok array_increment(2, 95_000_000, 1);
loop_over_array("chrom");
free_array();
done_testing;

这个测试用例的输出是

chrom   0       1       2
chrom   2       2       1

（删除了测试输出）。编译可能需要一秒钟，但在那之后应该很快。

于 2013-04-26T15:20:12.123 回答
0

在从 读取的记录中$bedgraph_fh， 的典型值是$start什么？@array尽管哈希每个条目的开销比数组多，但如果从大量未使用的条目开始，您可能会节省一些内存。例如，如果您有@array9000 万个元素，但前 8000 万个从未使用过，那么很有可能使用散列会更好。

除此之外，我没有看到任何明显的情况下此代码保留了它所实现的算法不需要的数据，尽管根据您的实际目标，可能会有一种替代算法不需要需要尽可能多的数据保存在内存中。

但是，如果您确实需要处理一组 9000 万个活动数据元素，那么您的主要选择将是购买大量 RAM 或使用某种形式的数据库。在后一种情况下，为了简单和轻量，我会选择 SQLite（通过DBD::SQLite ），但是 YMMV。

于 2013-04-26T10:47:09.840 回答