Повышение производительности скрипта поиска файлов Perl

Есть некоторые вещи, которые могут ускорить сценарий, например, удаление ненужного использования регулярных выражений.

• /^P\|/ эквивалентно "P|" eq substr $_, 0, 2.
• $foo =~ "BAR" может быть -1 != index $foo, "BAR".

Затем есть повторяющийся код. Внесение этого факторинга в подпрограмму не увеличит производительность как таковую, но упростит анализ поведения сценария.

Есть много ненужных строк, таких как "$filename" - $filename достаточно.

Но худшим нарушителем будет следующее:

for ( 1 .. $loop ) {
  ...
  open FILE, "<", $filename or ...
  while (<FILE>) {
    ...
  }
  ...
}

Вам нужно прочитать этот файл только один раз, желательно в массиве. Вы можете перебирать индексы:

for ( 1 .. $loop ) {
  ...
  for my $i (0 .. $#file_contents) {
    my $line = $file_contents[$i];
    ... # swap $. for $i, but avoid off-by-one error
  }
  ...
}

Дисковый ввод-вывод медленный, поэтому кэшируйте, где можете!

Я также вижу, что вы используете переменную $exclude как логическое значение со значениями FALSE и TRUECANC. Почему не 0 и 1, чтобы вы могли использовать их непосредственно в условном выражении?

Вы можете исключить общие тесты в if / elsif:

if    (FOO && BAR) { THING_A }
elsif (FOO && BAZ) { THING_B }

должно быть

if (FOO) {
    if    (BAR) { THING_A }
    elsif (BAZ) { THING_B }
}

Тест $. == $start && $line =~ /^P\|.../ может показаться глупым, потому что $start содержит только номера строк, начинающихся с P|, поэтому здесь может быть достаточно регулярного выражения.

Редактировать

Если я правильно понял сценарий, то следующее должно привести к значительному увеличению производительности:

#!/usr/bin/perl
use strict;
use warnings;

my ($filename, $cancfile) = @ARGV;
open my $fh, "<", $filename or die "$0: Couldn't open $filename: $!";

my (@num, @lines);
while (<$fh>)
{
    push @lines, $_;
    push @num, $#lines if "P|" eq substr $_, 0, 2;
}

open my $outcanc, ">>", $cancfile or die "$0: Couldn't open $cancfile: $!";

for my $i ( 0 .. $#num )
{
    my $start = $num[$i];
    my $end   = ($num[$i+1] // @lines) - 1;
    # pre v5.10:
    # my $end = (defined $num[$i+1] ? $num[$i+1] : @lines) - 1

    if ($lines[$start] =~ /^P[|][0-9]{9}[|]1I[|]IR[|]/) {
        print {$outcanc} @lines[$start .. $end];
    } else {
        print STDOUT     @lines[$start .. $end];
    }
}

Скрипт очищен. Файл кешируется в массиве. Итерируются только те части массива, которые действительно необходимы - мы уменьшились до O (n) по сравнению с предыдущим O (n · m).

Для ваших будущих скриптов: доказательство поведения вокруг циклов и изменяющихся переменных не невозможно, но утомительно и утомительно. Понимая, что

for (1 .. @num) {
  $start = shift @num unless $next;  # aka "do this only in the first iteration"
  $next = shift @num:
  $end = $next - 1:
  while (<FH>) {
    ...
    $test = $. if eof
    ...
  }
  $end = ++test if $end < $start;
  $start = $next if $next;
}

на самом деле все об обходе возможного undef во втором shift занимает некоторое время. Вместо того, чтобы проверять eof во внутреннем цикле, мы можем просто выбрать номер строки после цикла, поэтому $test нам не понадобится. Тогда получаем:

$start = shift @num;
for my $i (1 .. @num) {
  $end = $num[$i] - 1:

  while (<FH>) { ... }

  $end = $. + 1 if $end < $start;  # $end < $start only true if not defined $num[$i]
  $start = $num[$i] if $num[$i];
}

После перевода $i вниз на единицу мы ограничиваем проблему выхода за пределы только одной точкой:

for my $i (0 .. $#num) {
  $start = $num[$i];
  $end = $num[$i+1] - 1; # HERE: $end = -1 if $i == $#num

  while (<FH>) { ... }
}
$end = $. + 1 if $end < $start;

После замены чтения файла массивом (осторожно, существует разница в единицу между индексом массива и номером строки), мы видим, что последнего цикла чтения файла можно избежать, если мы перетащим эту итерацию в цикл for, потому что мы знать, сколько всего строк. Так сказать делаем

$end = ($num[$i+1] // $last_line_number) - 1;

Надеюсь, мой очищенный код действительно эквивалентен оригиналу.