Performance 如何改进Perl'；海量数据的性能如何？

我正在寻找改进我的算法来解决一个海量数据的谜题。 如果有人能想出一些好主意，让它运行得更快，我将不胜感激

我有8个文件，其中包含2个参数：

1） 起点

2） 终点

这些类型的数据在文件中以不同的数字重复。 意味着我可以有一个有200个起点+200个终点的文件，或者一个有50000个起点+50000个终点的文件

好的，这些数据可能反映X轴数据点。每个点的起点/终点将被排序到X_sort_数组中

问题从Y轴数据点开始

为了创建Y轴数据点，我制定了一些算法，在X_sort_数组点上运行，并检查每个点是否在所有起点和终点之间。如果为Y_数组[x_点]添加一个，依此类推

我将在这里粘贴大量代码，如果有语法/方法可以更高效地执行，我很乐意知道

当sort_all_legth大于50000时，慢动作开始：

    my $sort_all_length = @{$values{"$tasks_name[$i]\_sort\_allvals"}};
    my $core_count = 0;
    my $m=0;

    for my $k(0 .. $sort_all_length-1){



    if (($values{"$tasks_name[$i]\_sort\_allvals"}->[$k] eq $values{"$tasks_name[$i]\_sort\_allvals"}->[$k-1])
& ($k != 0) ) {
}

    else {
    my $pre_point_flag;
    # CHEACK PREVIUES POINT:
    for my $inst_num(0 .. $sort_all_length/2-1){
     $pre_point_flag=1;
     if ( ($values{"TID$i\_$tasks_name[$i]\_SHL"}->[$inst_num] <=    $values{"$tasks_name[$i]\_sort\_allvals"}->[$k]-1) 
   & ($values{"$tasks_name[$i]\_sort\_allvals"}->[$k]-1 <= $values{"TID$i\_$tasks_name[$i]\_EHL"}->[$inst_num]) )  {
    $pre_point_flag=0;
    last;
 }
}
if ($pre_point_flag eq 1){
 push(@{$values{"$tasks_name[$i]\_Y"}},0);
 push(@{$values{"$tasks_name[$i]\_X"}},$values{"$tasks_name[$i]\_sort\_allvals"}->[$k]-1);
}

# CHEACK DEFINE POINT:
for my $inst_num(0 .. $sort_all_length/2-1){
 if ( ($values{"TID$i\_$tasks_name[$i]\_SHL"}->[$inst_num] <= $values{"$tasks_name[$i]\_sort\_allvals"}->[$k]) 
   & ($values{"$tasks_name[$i]\_sort\_allvals"}->[$k] <= $values{"TID$i\_$tasks_name[$i]\_EHL"}->[$inst_num]) )  {
    $core_count++;
 }

}
push(@{$values{"$tasks_name[$i]\_Y"}},$core_count);
push(@{$values{"$tasks_name[$i]\_X"}},$values{"$tasks_name[$i]\_sort\_allvals"}->[$k]);

# CHEACK LATER POINT:
for my $inst_num(0 .. $sort_all_length/2-1){
 $pre_point_flag=1;
 if ( ($values{"TID$i\_$tasks_name[$i]\_SHL"}->[$inst_num] <= $values{"$tasks_name[$i]\_sort\_allvals"}->[$k]+1) 
   & ($values{"$tasks_name[$i]\_sort\_allvals"}->[$k]+1 <= $values{"TID$i\_$tasks_name[$i]\_EHL"}->[$inst_num]) )  {
    $pre_point_flag=0;
    last;
 }
}
if ($pre_point_flag eq 1){
 push(@{$values{"$tasks_name[$i]\_Y"}},0);
 push(@{$values{"$tasks_name[$i]\_X"}},$values{"$tasks_name[$i]\_sort\_allvals"}->[$k]+1);
}

if ($y_max_val < $core_count){
 $y_max_val = $core_count;
}

$core_count = 0;
$m++;
}



}

my$sort\u all\u length=@{$values{“$tasks\u name[$i]\\u sort\u allvals”}；
我的$core\u计数=0；
我的$m=0；
对于我的$k（0..$sort_all_length-1）{
if（$values{“$tasks\u name[$i]\\u sort\\u allvals”}->[$k]eq$values{“$tasks\u name[$i]\\u sort\\u allvals”}->[$k-1]）
&（$k！=0））{
}
否则{
我的$pre_point_旗帜；
#CHEACK PREVIUES点：
对于我的$inst_num（0..$sort_all_length/2-1）{
$pre_point_flag=1；
if（$values{“TID$i\\\$tasks\u name[$i]\\\u SHL”}->[$inst\u num][$k]-1）
&（$values{“$tasks\u name[$i]\\u sort\\u allvals”}->[$k]-1[$inst\u num]））{
$pre_point_flag=0；
最后；
}
}
if（$pre_点_标志等式1）{
push（@{$values{“$tasks\u name[$i]\\u Y”}，0）；
推送（@{$values{“$tasks\u name[$i]\\u X”}，$values{“$tasks\u name[$i]\\u sort\\u allvals”}->[$k]-1）；
}
#CHEACK定义点：
对于我的$inst_num（0..$sort_all_length/2-1）{
if（$values{“TID$i\\\$tasks\u name[$i]\\\u SHL”}->[$inst\u num][$k]）
&（$values{“$tasks\u name[$i]\\u sort\\u allvals”}->[$k][$inst\u num]））{
$core_count++；
}
}
push（@{$values{“$tasks\u name[$i]\\u Y”}，$core\u count）；
推送（@{$values{“$tasks\u name[$i]\\u X”}，$values{“$tasks\u name[$i]\\u sort\\u allvals”}->[$k]）；
#切克：稍后的要点：
对于我的$inst_num（0..$sort_all_length/2-1）{
$pre_point_flag=1；
如果（$values{“TID$i\\\$tasks\u name[$i]\\\u SHL”}->[$inst\u num][$k]+1）
&（$values{“$tasks\u name[$i]\\u sort\\u allvals”}->[$k]+1[$inst\u num]））{
$pre_point_flag=0；
最后；
}
}
if（$pre_点_标志等式1）{
push（@{$values{“$tasks\u name[$i]\\u Y”}，0）；
推送（@{$values{“$tasks\u name[$i]\\u X”}，$values{“$tasks\u name[$i]\\u sort\\u allvals”}->[$k]+1）；
}
如果（$y_max_val<$core_count）{
$y_max_val=$core_count；
}
$core_count=0；
$m++；
}
}

具有良好性能的小数据示例：

（性能差导致I.p大小为50000！）

数据库：任务：字节位置

数据库：二进制文件大小：3216

数据库：开始/结束值的数量=804

数据库：在已排序的I.p阵列（大小：1608）中计数活动核

数据库：I.p数组值：

375127997351350233751771213751779783752254843755226331， 375273745,375274563,375320063,375325255,375372479,375377085, 375422115,375422896,375473198,375474058,375517412,375518169, 375561967375562760375606301375607092

测试示例输入/输出：

输入是X轴上的起点和终点：

16255

16255

16255

100355

200455

数据库：任务：测试

数据库：二进制文件大小：20

数据库：开始/结束值的数量=5

数据库：已排序的I.p数组（X轴）：

16,16,1610025255255355455

这些点中的每一个都称为有趣的点（在X轴上）

为了计算Y值，我用每个I.p.绘制一条垂直线

然后我计算有多少条输入线（起点/终点）穿过第一条垂直线

结果是第一个X I.p的第一个Y点

数据库：在已排序的I.p阵列（大小：10）中计算活动核心

输出向量：

数据库：排序核心阵列（Y轴）：

0,3,4,5,5,2,1,0

在我的算法中，我在开始/结束一个块的每个I.p之前和之后添加了另一个点

这就是你可以在开头/结尾看到零的方式

3-表示在X点16处有3条切片线

4-表示在X点100处有4条切片线

5-（1）表示在X点200处有5条切片线

5-（2）表示在X点255处有5条切片线

2-表示在X点355处有2条切片线

1-表示在X点455处有1条切片线

希望这些扩展示例能让您更了解算法。：）

我将重新编译代码以提高可读性

谢谢，

---

Yodar.

提高性能的一个非常简单的方法就是学习更好的编码实践

你忽略的一个原则是：不要重复你自己

您在其中多次重复某些代码位，迫使Perl一次又一次地对同一表达式求值。例如，此字符串：

"$tasks_name[$i]\_sort\_allvals"

在那里大约用了10次。这意味着每次使用它时，perl都会引用数组，以防它发生变化，并将该字符串组合在一起。这看起来可能不多，但最终会累积起来

另一个例子是：

$values{"$tasks_name[$i]\_sort\_allvals"}->[$k]

---

它也被使用了10次，虽然$k实际上改变了每个循环，但是对于循环中的每个运行，整个表达式的值都是相同的。在循环开始时将其存储在单个标量中，然后在循环的其余部分使用该标量会更快，因为可以避免迫使perl在每个循环中解析引用10次。

我在跟踪它时遇到了一些问题，但听起来像是在搜索（方便地预排序）数据数组

database: task: TEST

database: binary file size: 20

database: numbers of start/end values = 5

database: sorted I.P array (X axis):

16,16,16,100,200,255,255,255,355,455

database: counting active cores in sorted I.P array (size: 10)...

database: sorted cores array (Y axis):

0,3,4,5,5,2,1,0

sub binary_range_search {
    my ( $range, $ranges ) = @_;
    my ( $low, $high ) = ( 0, @{$ranges} - 1 );
    while ( $low <= $high ) {

        my $try = int( ( $low + $high ) / 2 );

        $low  = $try + 1, next if $ranges->[$try][1] < $range->[0];
        $high = $try - 1, next if $ranges->[$try][0] > $range->[1];

        return $ranges->[$try];
    }
    return;
}

struct point {
   int start, int stop      
}  

point array[8000];
read array form file;
for (int i=0; i<8000; i++)
{
}

#!/usr/bin/env perl

use strict;
use warnings;

my (@starts, @ends);

while(<>) {
    chomp;
    my($start, $end) = split',';
    push @starts, $start;
    push @ends, $end;
}

@starts = sort { $a <=> $b } @starts;
@ends = sort { $a <=> $b } @ends;

my $y = 0;
my ($x, @y, @x);
while (@starts) {
    my $x = $starts[0] <= $ends[0] ? $starts[0] : $ends[0];
    while ($starts[0] == $x) {
        $y++;
        shift @starts;
        last unless @starts;
    }
    push @x, $x;
    push @y, $y;
    while ($ends[0] == $x) {
        $y--;
        shift @ends;
        last unless @ends;
    }
}

while (@ends) {
    my $x = $ends[0];
    push @x, $x;
    push @y, $y;
    while ($ends[0] == $x) {
        $y--;
        shift @ends;
        last unless @ends;
    }
}

die "Unbalanced!" if $y;

$" = ',';
print "0,@y,0\n";