В чем причина различий в производительности поиска по подстроке с использованием «index ()» по сравнению с RegEx в Perl?

Question

Я предполагаю, что может быть разница в эффективности между:

if (index($string, "abc") < -1) {}

и

if ($string !~ /abc/) {}

Может ли кто-нибудь подтвердить, что это так, основываясь на том, как они реализованы в Perl (в отличие от чистого бенчмаркинга)?

Я, очевидно, могу предположить, как реализованы оба (основываясь на том, как я написал бы оба в C), но хотел бы получить более информированный ответ, в идеале основанный на фактическом perl исходном коде.

---

Вот мой собственный пример теста:

                          Rate regex.FIND_AT_END    index.FIND_AT_END
regex.FIND_AT_END     639345/s                   --                 -88%
index.FIND_AT_END    5291005/s                 728%                   --
                          Rate regex.NOFIND         index.NOFIND
regex.NOFIND          685260/s                   --                 -88%
index.NOFIND         5515720/s                 705%                   --
                          Rate regex.FIND_AT_START  index.FIND_AT_START
regex.FIND_AT_START   672269/s                   --                 -90%
index.FIND_AT_START  7032349/s                 946%                   --

##############################
use Benchmark qw(:all);

my $count = 10000000;
my $re = qr/abc/o;
my %tests = (
    "NOFIND        " => "cvxcvidgds.sdfpkisd[s"
   ,"FIND_AT_END   " => "cvxcvidgds.sdfpabcd[s"
   ,"FIND_AT_START " => "abccvidgds.sdfpkisd[s"
);

foreach my $type (keys %tests) {
    my $str = $tests{$type};
    cmpthese($count, {
        "index.$type" => sub { my $idx = index($str, "abc"); },
        "regex.$type" => sub { my $idx = ($str =~ $re); }
    });
}

Answer 1

Посмотрите на функцию Perl_instr:

 430 char *
 431 Perl_instr(register const char *big, register const char *little)
 432 {
 433     register I32 first;
 434 
 435     PERL_ARGS_ASSERT_INSTR;
 436 
 437     if (!little)
 438         return (char*)big;
 439     first = *little++;
 440     if (!first)
 441         return (char*)big;
 442     while (*big) {
 443         register const char *s, *x;
 444         if (*big++ != first)
 445             continue;
 446         for (x=big,s=little; *s; /**/ ) {
 447             if (!*x)
 448                 return NULL;
 449             if (*s != *x)
 450                 break;
 451             else {
 452                 s++;
 453                 x++;
 454             }
 455         }
 456         if (!*s)
 457             return (char*)(big-1);
 458     }
 459     return NULL;
 460 }

Сравните с S_regmatch .Мне кажется, что в regmatch есть некоторые издержки по сравнению с index; -)