Анализ скорости выполнения Perl операторов и функций (benchmark perl speed optimization)
Ключевые слова: benchmark, perl, speed, optimization, (найти похожие документы)
Date: Fri, 22 Nov 2002 04:22:02 +0500
From: Andrey Sapozhnikov <[email protected]>
Newsgroups: ftn.ru.perl
Subject: Анализ скорости выполнения Perl операторов и функций
>> Ведь grep тоже, насколько мне известно, возвращает список. И вообще,
>> если записать @arr = map{$words{$_}++}@words, то map работает как раз
>> в те самые полтора раза быстрее, чем без присваивания массиву, в то
>> время как grep в таком же случае начинает работать медленней (не
>> поверите!) приблизительно в те же полтора раза. Вот такие хитрые
>> сообщающиеся сосуды...
>
> Вот это уже интересно. Hе, базу пусть Андрей подводит... Он сырцы читал.
Прежде чем подводить базу я позволил себе еще раз провести бенчмарки.
Сорри за длинный постинг. Зато достаточно полный.
====================== test.pl =======================
#!/usr/bin/perl -w
use strict;
use Benchmark;
my @words = (qw(a b c a b c c d ftg g htg ftg tgtg gg h rg tg t t tg yg))
x 12000;
my @swords = sort @words;
timethese -10, {
'foreach' => sub {
my %w;
foreach (@words) {
$w{$_}++;
}
},
'oneline' => sub {
my %w;
$w{$_}++ foreach @words;
},
'void map' => sub {
my %w;
map $w{$_}++, @words;
1;
},
'map' => sub {
my %w;
my @arr = map $w{$_}++, @words;
},
'void block map' => sub {
my %w;
map { $w{$_}++ } @words;
1;
},
'block map' => sub {
my %w;
my @arr = map { $w{$_}++ } @words;
},
'void grep' => sub {
my %w;
grep $w{$_}++, @words;
1;
},
'grep' => sub {
my %w;
my @arr = grep $w{$_}++, @words;
},
'void block grep' => sub {
my %w;
grep { $w{$_}++ } @words;
1;
},
'block grep' => sub {
my %w;
my @arr = grep { $w{$_}++ } @words;
},
'sorted foreach' => sub {
my %w;
foreach (@swords) {
$w{$_}++;
}
},
'sorted oneline' => sub {
my %w;
$w{$_}++ foreach @swords;
},
'sorted void map' => sub {
my %w;
map $w{$_}++, @swords;
1;
},
'sorted map' => sub {
my %w;
my @arr = map $w{$_}++, @swords;
},
'sorted void block map' => sub {
my %w;
map { $w{$_}++ } @swords;
1;
},
'sorted block map' => sub {
my %w;
my @arr = map { $w{$_}++ } @swords;
},
'sorted void grep' => sub {
my %w;
grep $w{$_}++, @swords;
1;
},
'sorted grep' => sub {
my %w;
my @arr = grep $w{$_}++, @swords;
},
'sorted void block grep' => sub {
my %w;
grep { $w{$_}++ } @swords;
1;
},
'sorted block grep' => sub {
my %w;
my @arr = grep { $w{$_}++ } @swords;
},
};
============================== EOF ==============================
============================ output =============================
Benchmark: running block grep, block map, foreach, grep, map, oneline,
sorted block grep, sorted block map, sorted foreach, sorted grep, sorted
map, sorted oneline, sorted void block grep, sorted void block map,
sorted void grep, sorted void map, void block grep, void block map, void
grep, void map for at least 10 CPU seconds...
block grep: 11 wallclock secs (11.19 usr + 0.00 sys = 11.19 CPU) @
0.80/s (n=9)
block map: 11 wallclock secs (10.75 usr + 0.01 sys = 10.76 CPU) @
1.30/s (n=14)
foreach: 10 wallclock secs (10.11 usr + 0.01 sys = 10.12 CPU) @
2.77/s (n=28)
grep: 11 wallclock secs (10.94 usr + 0.00 sys = 10.94 CPU) @
1.01/s (n=11)
map: 10 wallclock secs (10.55 usr + 0.00 sys = 10.55 CPU) @
1.33/s (n=14)
oneline: 10 wallclock secs (10.46 usr + 0.00 sys = 10.46 CPU) @
2.87/s (n=30)
sorted block grep: 10 wallclock secs (10.09 usr + 0.07 sys = 10.16 CPU)
@ 0.98/s (n=10)
sorted block map: 11 wallclock secs (10.70 usr + 0.00 sys = 10.70 CPU)
@ 1.31/s (n=14)
sorted foreach: 10 wallclock secs (10.01 usr + 0.00 sys = 10.01 CPU) @
2.80/s (n=28)
sorted grep: 11 wallclock secs (10.66 usr + 0.11 sys = 10.77 CPU) @
1.02/s (n=11)
sorted map: 10 wallclock secs (10.48 usr + 0.00 sys = 10.48 CPU) @
1.34/s (n=14)
sorted oneline: 10 wallclock secs (10.27 usr + 0.00 sys = 10.27 CPU) @
2.92/s (n=30)
sorted void block grep: 10 wallclock secs (10.07 usr + 0.00 sys = 10.07
CPU) @ 2.68/s (n=27)
sorted void block map: 10 wallclock secs (10.33 usr + 0.00 sys = 10.33
CPU) @ 1.84/s (n=19)
sorted void grep: 10 wallclock secs (10.14 usr + 0.01 sys = 10.15 CPU)
@ 2.76/s (n=28)
sorted void map: 10 wallclock secs (10.15 usr + 0.01 sys = 10.16 CPU) @
1.87/s (n=19)
void block grep: 10 wallclock secs (10.15 usr + 0.01 sys = 10.16 CPU) @
2.66/s (n=27)
void block map: 10 wallclock secs (10.38 usr + 0.00 sys = 10.38 CPU) @
1.83/s (n=19)
void grep: 10 wallclock secs (10.18 usr + 0.00 sys = 10.18 CPU) @
2.75/s (n=28)
void map: 11 wallclock secs (10.31 usr + 0.02 sys = 10.33 CPU) @
1.84/s (n=19)
============================== EOF ==============================
Из чего делаем выводы:
1. Сортировка существенного влияния на скорость не оказывает.
2. Самый быстрый оператор цикла - однострочный (постфиксный) foreach.
3. Традиционный foreach и grep ничего никуда не возвращающий
работают чуть медленнее, но примерно одинаково. Однако следите за тем,
чтоб и вправду ничего не возвращалось ибо будучи расположенным в
последней строке функции оператор неявно сработает как return grep ...
4. "void-context" ускоряет и grep и map. Причем grep ускоряется
много сильнее. Здесь сказывается то, что алгоритм работы grep
для скалярного контекста становится много проще. Исполнение выражения
и (если true) инкремент счетчика, а в map внутреннее выражение
продолжает исполняться в списковом контексте после чего полученный
"минисписок" уничтожается, а к счетчику добавляется его размер.
5. Использование блоков кода { code } вместо code очень немного, но
стабильно снижает производительность.
Кто еще наблюдает какие-либо странности в данном тесте и
имеет вопросы - задавайте.
From: Timur Vafin <[email protected]>
V>> Кто может подсказать, почему map работает медленнее прямого перебора
V>> массива?
AC> Потому что он генерирует новый список. А то, что тебе результат не нужен,
AC> для него не аргумент.
Что то не пойму...
#!/usr/bin/perl -w
use Benchmark;
@junk = `cat /etc/motd`;
$count = 100_000;
timethese($count, {
'map' => sub { my @a = @junk;
map { s/a/b/ } @a;
},
'for' => sub { my @a = @junk;
foreach (@a) { s/a/b/ };
},
});
Результат:
Benchmark: timing 100000 iterations of for, map...
for: 0 wallclock secs ( 0.22 usr + 0.00 sys = 0.22 CPU) @
454545.45/s (n=100000)
(warning: too few iterations for a reliable count)
map: 0 wallclock secs ( 0.14 usr + -0.01 sys = 0.13 CPU) @
769230.77/s (n=100000)
(warning: too few iterations for a reliable count)
| 1, korob2001 (?), 13:27, 01/07/2003 [ответить]
| +/– |
 Я читал, что самый быстрый оператор цикла это foreach, в таком виде:
foreach(@arr) {print};
Как и показал ваш тест.
Но в некоторых ситуациях, например - когда в файле много строк и нужно пройти циклически каждую, for бысрее:
for(@arr) {print}; | | |
| |
| 2, Остров (?), 08:38, 02/05/2005 [^] [^^] [^^^] [ответить]
| +/– | |
foreach и for это __СИНОНИМЫ__ при том использовании, которое указано. А отличие результатов - не корректность тестов. | | |
|
|
