perlperf - Online sa Cloud

PROGRAMA:

NAME

perlperf - Perl Performance at Optimization Techniques

DESCRIPTION

Ito ay isang panimula sa paggamit ng pagganap at mga diskarte sa pag-optimize na maaaring
ginamit na may partikular na sanggunian sa mga perl program. Habang maraming perl developer ang dumating
mula sa ibang mga wika, at maaaring gamitin ang kanilang dating kaalaman kung saan naaangkop, marami
ibang mga tao na maaaring makinabang mula sa ilang partikular na pointer ng perl. Kung gusto mo ang
condensed na bersyon, marahil ang pinakamahusay na payo ay mula sa kilalang Japanese Samurai,
Miyamoto Musashi, na nagsabi:

"Huwag Makisali sa Walang Kabuluhang Gawain"

sa 1645.

PANGKALAHATANG-IDEYA

Marahil ang pinakakaraniwang pagkakamali ng mga programmer ay ang pagtatangka na i-optimize ang kanilang code
bago ang isang programa ay aktwal na gumawa ng anumang kapaki-pakinabang - ito ay isang masamang ideya. Walang saysay na
pagkakaroon ng napakabilis na programa na hindi gumagana. Ang unang trabaho ay upang makakuha ng isang programa sa
wasto gumawa ng paraan kapaki-pakinabang, (hindi banggitin ang pagtiyak na ang test suite ay ganap
functional), at pagkatapos lamang isaalang-alang ang pag-optimize nito. Ang pagkakaroon ng nagpasya na i-optimize ang umiiral na
working code, may ilang simple ngunit mahahalagang hakbang na dapat isaalang-alang kung alin ang intrinsic
sa anumang proseso ng pag-optimize.

ONE HAKBANG TABILIN
Una, kailangan mong magtatag ng baseline na oras para sa umiiral na code, na kailangan ng timing
upang maging maaasahan at mauulit. Malamang na gusto mong gamitin ang "Benchmark" o
"Devel::NYTProf" na mga module, o katulad na bagay, para sa hakbang na ito, o marahil ang Unix system
"time" utility, alinman ang naaangkop. Tingnan ang base ng dokumentong ito para sa mas mahabang listahan
ng benchmarking at profiling modules, at inirerekomenda ang karagdagang pagbabasa.

ONE HAKBANG FORWARD
Susunod, napagmasdan ang programa para sa mainit spot, (mga lugar kung saan tila tumatakbo ang code
dahan-dahan), baguhin ang code na may layuning patakbuhin ito nang mas mabilis. Gamit ang bersyon
ang control software, tulad ng "subversion", ay titiyakin na walang pagbabagong hindi maibabalik. Ito ay masyadong
madaling magbiyolin dito at magbiyolin doon - huwag masyadong magbago anumang oras o maaari
hindi matuklasan kung aling piraso ng code Talaga ay ang mabagal na bit.

ISA PANG HAKBANG TABILIN
Hindi sapat na sabihing: "that will make it run faster", kailangan mong suriin ito. Patakbuhin muli ang
code sa ilalim ng kontrol ng benchmarking o profiling modules, mula sa unang hakbang sa itaas,
at suriin na ang bagong code ay nagsagawa ng pareho gawain in kulang oras. I-save ang iyong trabaho at
ulitin...

PANGKALAHATAN MGA Gabay

Ang kritikal na bagay kapag isinasaalang-alang ang pagganap ay tandaan na walang ganoong bagay bilang a
"Golden Bullet", kaya naman walang rules, guidelines lang.

Malinaw na ang inline na code ay magiging mas mabilis kaysa sa subroutine o mga method na tawag,
dahil may mas kaunting overhead, ngunit ang diskarte na ito ay may kawalan ng pagiging mas mababa
mapanatili at may halaga ng mas malaking paggamit ng memorya - walang ganoong bagay bilang a
libreng tanghalian. Kung naghahanap ka ng elemento sa isang listahan, maaari itong maging mas mahusay
iimbak ang data sa isang istraktura ng hash, at pagkatapos ay tingnan lamang kung ang susi ay
tinukoy, sa halip na mag-loop sa buong array gamit grep() halimbawa. substr()
maaaring (maraming) mas mabilis kaysa grep() ngunit hindi kasing flexible, kaya mayroon kang isa pang trade-off
access. Ang iyong code ay maaaring maglaman ng isang linya na tumatagal ng 0.01 ng isang segundo upang maipatupad na kung ikaw
tawagan ito ng 1,000 beses, malamang na sa isang programa ay nag-parse kahit katamtamang laki ng mga file para sa
halimbawa, mayroon ka nang 10 segundong pagkaantala, sa isang solong lokasyon ng code, at kung ikaw
tawagan ang linyang iyon ng 100,000 beses, ang iyong buong programa ay bumagal sa isang hindi mabata na pag-crawl.

Ang paggamit ng subroutine bilang bahagi ng iyong uri ay isang mahusay na paraan para makuha kung ano mismo ang gusto mo,
ngunit kadalasan ay mas mabagal kaysa sa built-in alpabeto "cmp" at numeric "<=>" pag-uuri
mga operator. Posibleng gumawa ng maraming pagpasa sa iyong data, pagbuo ng mga indeks sa
gawing mas mahusay ang paparating na pag-uuri, at gamitin ang tinatawag na "OM" (Orcish
Maneuver) upang i-cache ang mga key ng pag-uuri nang maaga. Ang paghahanap ng cache, habang isang magandang ideya, maaari
ang mismong pinagmulan ng pagbagal sa pamamagitan ng pagpapatupad ng double pass sa data - isang beses sa pag-setup
ang cache, at isang beses upang ayusin ang data. Gamit ang "pack()" para kunin ang kinakailangang sort key
sa isang pare-parehong string ay maaaring maging isang mahusay na paraan upang bumuo ng isang solong string upang ihambing,
sa halip na gumamit ng maramihang mga sort key, na ginagawang posible na gamitin ang pamantayan, nakasulat
sa "c" at mabilis, perl "sort()" function sa output, at ang batayan ng "GRT"
(Pagbabago ni Guttman Rossler). Maaaring pabagalin ng ilang kumbinasyon ng string ang "GRT", sa pamamagitan lamang
pagiging masyadong simpleng kumplikado para sa sarili nitong kabutihan.

Para sa mga application na gumagamit ng database backends, ang karaniwang "DBix" namespace ay sumusubok na tumulong
sa pagpapanatiling maliksi ang mga bagay, hindi bababa sa dahil sinusubukan nitong gawin hindi i-query ang database hanggang sa
pinakabagong posibleng sandali, ngunit palaging basahin ang mga doc na kasama ng iyong napiling mga aklatan.
Kabilang sa maraming mga isyu na kinakaharap ng mga developer na nakikitungo sa mga database ay dapat manatiling nalalaman ay
para laging gumamit ng mga placeholder na "SQL" at isaalang-alang ang paunang pagkuha ng mga set ng data kung kailan ito maaaring
patunayang may pakinabang. Paghahati ng malaking file sa pamamagitan ng pagtatalaga ng maraming proseso sa pag-parse
ang isang file, gamit ang say "POE", "threads" o "fork" ay maaari ding maging isang kapaki-pakinabang na paraan ng pag-optimize
ang iyong paggamit ng mga magagamit na mapagkukunan ng "CPU", kahit na ang diskarteng ito ay puno ng
mga isyu sa concurrency at nangangailangan ng mataas na atensyon sa detalye.

Ang bawat kaso ay may partikular na aplikasyon at isa o higit pang mga pagbubukod, at wala
kapalit para sa pagpapatakbo ng ilang mga pagsubok at pag-alam kung aling paraan ang pinakamahusay para sa iyo
partikular na kapaligiran, ito ang dahilan kung bakit ang pagsulat ng pinakamainam na code ay hindi isang eksaktong agham, at bakit
gustung-gusto naming gumamit ng Perl - TMTOWTDI.

BENCHMARKS

Narito ang ilang mga halimbawa upang ipakita ang paggamit ng mga tool sa benchmarking ng Perl.

Pagtatalaga at Dereferencing Mga variable
Sigurado akong karamihan sa atin ay nakakita ng code na parang, (o mas masahol pa), ito:

kung ( $obj->{_ref}->{_myscore} >= $obj->{_ref}->{_yourscore} ) {
...

Ang ganitong uri ng code ay maaaring maging isang tunay na hindi magandang basahin, pati na rin ang pagiging sensitibo sa mga typo,
at mas malinaw na i-dereference ang variable nang tahasan. Kami ay side-stepping ang
isyu ng pagtatrabaho sa object-oriented programming techniques para i-encapsulate ang variable
access sa pamamagitan ng mga pamamaraan, naa-access lamang sa pamamagitan ng isang bagay. Dito lang natin tinatalakay ang
teknikal na pagpapatupad ng pagpili, at kung ito ay may epekto sa pagganap. kaya natin
tingnan kung ang pagpapatakbo ng dereferencing na ito, ay may anumang overhead sa pamamagitan ng paglalagay ng comparative code
isang file at nagpapatakbo ng isang "Benchmark" na pagsubok.

# dereference

#!/usr/bin/perl

gumamit ng mahigpit;
gumamit ng mga babala;

gumamit ng Benchmark;

aking $ref = {
'ref' => {
_myscore => '100 + 1',
_yourscore => '102 - 1',
},
};

timethese(1000000, {
'direkta' => sub {
aking $x = $ref->{ref}->{_myscore} . $ref->{ref}->{_yourscore} ;
},
'dereference' => sub {
aking $ref = $ref->{ref};
aking $myscore = $ref->{_myscore};
ang aking $yourscore = $ref->{_yourscore};
aking $x = $myscore . $yourscore;
},
});

Mahalagang patakbuhin ang anumang mga pagsukat ng timing ng sapat na bilang ng beses upang ang mga numero
tumira sa isang numerical average, kung hindi, ang bawat pagtakbo ay natural na magbabago dahil sa
mga pagkakaiba-iba sa kapaligiran, upang mabawasan ang epekto ng pagtatalo para sa mga mapagkukunan ng "CPU" at
bandwidth ng network halimbawa. Ang pagpapatakbo ng code sa itaas para sa isang milyong pag-ulit, magagawa namin
tingnan ang output ng ulat ng "Benchmark" na module, upang makita kung aling diskarte ang
pinakamabisa.

$> perl dereference

Benchmark: timing ng 1000000 na pag-ulit ng dereference, direktang...
dereference: 2 wallclock seg ( 1.59 usr + 0.00 sys = 1.59 CPU) @ 628930.82/s (n=1000000)
direkta: 1 wallclock seg ( 1.20 usr + 0.00 sys = 1.20 CPU) @ 833333.33/s (n=1000000)

Ang pagkakaiba ay malinaw na makita at ang dereferencing diskarte ay mas mabagal. Habang ito ay pinamamahalaan
upang maisagawa ang isang average na 628,930 beses sa isang segundo sa panahon ng aming pagsubok, ang direktang diskarte
nagawang magpatakbo ng karagdagang 204,403 beses, sa kasamaang-palad. Sa kasamaang palad, dahil doon
ay maraming halimbawa ng code na isinulat gamit ang multiple layer direct variable access, at
ito ay karaniwang kakila-kilabot. Gayunpaman, ito ay mas mabilis. Ang tanong ay nananatiling kung
ang minutong pakinabang ay talagang katumbas ng pagkapagod sa mata, o ang pagkawala ng kakayahang mapanatili.

Maghanap at palitan or tr
Kung mayroon kaming isang string na kailangang baguhin, habang ang isang regex ay halos palaging magkano
mas nababaluktot, ang "tr", isang madalas na hindi gaanong ginagamit na tool, ay maaari pa ring maging kapaki-pakinabang. Maaaring isang senaryo
palitan ang lahat ng patinig ng ibang karakter. Maaaring ganito ang hitsura ng regex solution:

$str =~ s/[aeiou]/x/g

Maaaring ganito ang hitsura ng alternatibong "tr":

$str =~ tr/aeiou//

Maaari naming ilagay iyon sa isang test file na maaari naming patakbuhin upang suriin kung aling diskarte ang pinakamabilis,
gumagamit ng pandaigdigang variable na $STR para italaga sa variable na "my $str" para maiwasan ang perl
sinusubukang i-optimize ang alinman sa mga gawain sa pamamagitan ng pagpansin na minsan lang itong itinalaga.

# regex-transliterate

#!/usr/bin/perl

gumamit ng mahigpit;
gumamit ng mga babala;

gumamit ng Benchmark;

aking $STR = "$$-ito at iyon";

timethese( 1000000, {
'sr' => sub { my $str = $STR; $str =~ s/[aeiou]/x/g; ibalik ang $str; },
'tr' => sub { my $str = $STR; $str =~ tr/aeiou//; ibalik ang $str; },
});

Ang pagpapatakbo ng code ay nagbibigay sa amin ng aming mga resulta:

$> perl regex-transliterate

Benchmark: timing ng 1000000 na pag-ulit ng sr, tr...
sr: 2 wallclock seg ( 1.19 usr + 0.00 sys = 1.19 CPU) @ 840336.13/s (n=1000000)
tr: 0 wallclock seg ( 0.49 usr + 0.00 sys = 0.49 CPU) @ 2040816.33/s (n=1000000)

Ang "tr" na bersyon ay isang malinaw na nagwagi. Ang isang solusyon ay nababaluktot, ang isa ay mabilis - at
naaangkop ang pagpili ng programmer kung alin ang gagamitin.

Suriin ang mga dokumentong "Benchmark" para sa karagdagang kapaki-pakinabang na mga diskarte.

PAG-PROFILE TOOL

Ang isang bahagyang mas malaking piraso ng code ay magbibigay ng isang bagay na maaaring gawin ng isang profiler
mas malawak na istatistika ng pag-uulat. Ang halimbawang ito ay gumagamit ng simplistic na "wordmatch" na programa
na nag-parse ng ibinigay na input file at naglalabas ng maikling ulat sa mga nilalaman.

# wordmatch

#!/usr/bin/perl

gumamit ng mahigpit;
gumamit ng mga babala;

=head1 PANGALAN

filewords - pagsusuri ng salita ng input file

=head1 SYNOPSIS

filewords -f inputfilename [-d]

=head1 DESCRIPTION

Ang program na ito ay nag-parse ng ibinigay na filename, na tinukoy sa C<-f>, at nagpapakita ng a
simpleng pagsusuri sa mga salitang matatagpuan dito. Gamitin ang C<-d> switch para paganahin
pag-debug ng mga mensahe.

= gupitin

gamitin ang FileHandle;
gamitin ang Getopt::Long;

aking $debug = 0;
aking $file = '';

my $result = GetOptions (
'debug' => \$debug,
'file=s' => \$file,
);
die("invalid args") maliban kung $result;

maliban kung ( -f $file ) {
die("Paggamit: $0 -f filename [-d]");
}
my $FH = FileHandle->new("< $file") or die("unable to open file($file): $!");

aking $i_LINES = 0;
aking $i_WORDS = 0;
aking %count = ();

aking @lines = <$FH>;
foreach my $line ( @lines ) {
$i_LINES++;
$line =~ s/\n//;
my @words = split(/ +/, $line);
my $i_words = scalar(@words);
$i_WORDS = $i_WORDS + $i_words;
debug("linya: $i_LINES na nagbibigay ng $i_words na mga salita: @words");
aking $i_word = 0;
foreach my $word ( @words ) {
$i_word++;
$count{$i_LINES}{spec} += matches($i_word, $word, '[^a-zA-Z0-9]');
$count{$i_LINES}{only} += matches($i_word, $word, '^[^a-zA-Z0-9]+$');
$count{$i_LINES}{cons} += matches($i_word, $word, '^[(?i:bcdfghjklmnpqrstvwxyz)]+$');
$count{$i_LINES}{vows} += matches($i_word, $word, '^[(?i:aeiou)]+$');
$count{$i_LINES}{caps} += matches($i_word, $word, '^[(AZ)]+$');
}
}

i-print ang ulat(%count);

sub matches {
aking $i_wd = shift;
aking $word = shift;
aking $regex = shift;
ang aking $has = 0;

kung ($word =~ /($regex)/ ) {
$has++ kung $1;
}

debug("salita: $i_wd ".($may ? 'tugma' : 'hindi tumutugma')." chars: /$regex/");

ibalik ang $has;
}

sub report {
aking %ulat = @_;
ang aking %rep;

foreach my $line ( keys %report ) {
foreach my $key ( keys %{ $ulat{$line} } ) {
$rep{$key} += $ulat{$line}{$key};
}
}

aking $ulat = qq|
$0 na ulat para sa $file:
mga linya sa file: $i_LINES
mga salita sa file: $i_WORDS
mga salitang may espesyal (hindi salita) na mga character: $i_spec
mga salita na may tanging espesyal (hindi salita) na mga character: $i_only
mga salitang may lamang katinig: $i_cons
mga salitang may malalaking titik lamang: $i_caps
mga salitang may lamang patinig: $i_vows
|;

ibalik ang $ulat;
}

sub debug {
my $message = shift;

kung ($debug) {
i-print ang STDERR "DBG: $message\n";
}
}

exit 0;

Devel::DPof
Ang kagalang-galang na module na ito ay ang de-facto na pamantayan para sa Perl code profiling nang higit sa
isang dekada, ngunit napalitan ito ng ilang iba pang mga module na nagpabalik sa atin
ika-21 siglo. Bagama't inirerekumenda mong suriin ang iyong tool mula sa ilan
binanggit dito at mula sa listahan ng CPAN sa base ng dokumentong ito, (at sa kasalukuyan
Devel::NYTProf ay tila ang sandata na pinili - tingnan sa ibaba), titingnan natin nang mabilis
ang output mula sa Devel::DProf muna, upang magtakda ng baseline para sa Perl profiling tools. Patakbuhin ang
programa sa itaas sa ilalim ng kontrol ng "Devel::DProf" sa pamamagitan ng paggamit ng "-d" switch sa command-
linya.

$> perl -d:DPof wordmatch -f perl5db.pl

<...maraming linya ang pinutol...>

ulat ng wordmatch para sa perl5db.pl:
mga linya sa file: 9428
mga salita sa file: 50243
mga salitang may espesyal (hindi salita) na mga character: 20480
mga salitang may mga espesyal na (hindi salita) na mga character lamang: 7790
mga salitang may mga katinig lamang: 4801
mga salitang may malalaking titik lamang: 1316
mga salitang may lamang patinig: 1701

Ang "Devel::DProf" ay gumagawa ng isang espesyal na file, na tinatawag tmon.out bilang default, at binabasa ang file na ito
sa pamamagitan ng "dprofpp" program, na naka-install na bilang bahagi ng "Devel::DProf"
pamamahagi. Kung tatawagan mo ang "dprofpp" nang walang mga pagpipilian, babasahin nito ang tmon.out file sa
ang kasalukuyang direktoryo at gumawa ng isang nababasa ng tao na ulat ng istatistika ng pagpapatakbo ng iyong
programa. Tandaan na maaaring tumagal ito ng kaunting oras.

$> dprofpp

Kabuuang Lumipas na Oras = 2.951677 Segundo
Oras ng User+System = 2.871677 Segundo
Eksklusibong Panahon
%Time ExclSec CumulS #Calls sec/call Csec/c Name
102. 2.945 3.003 251215 0.0000 0.0000 main::matches
2.40 0.069 0.069 260643 0.0000 0.0000 main::debug
1.74 0.050 0.050 1 0.0500 0.0500 pangunahing::ulat
1.04 0.030 0.049 4 0.0075 0.0123 main::BEGIN
0.35 0.010 0.010 3 0.0033 0.0033 Exporter::as_heavy
0.35 0.010 0.010 7 0.0014 0.0014 IO::File::BEGIN
0.00 - -0.000 1 - - Getopt::Long::FindOption
0.00 - -0.000 1 - - Simbolo:: BEGIN
0.00 - -0.000 1 - - Fcntl::BEGIN
0.00 - -0.000 1 - - Fcntl::bootstrap
0.00 - -0.000 1 - - mga babala::BEGIN
0.00 - -0.000 1 - - IO::bootstrap
0.00 - -0.000 1 - - Getopt::Long::ConfigDefaults
0.00 - -0.000 1 - - Getopt::Long::I-configure
0.00 - -0.000 1 - - Simbolo::gensym

Ang "dprofpp" ay gagawa ng ilang medyo detalyadong pag-uulat sa aktibidad ng "wordmatch"
programa. Ang wallclock, user at system, ang mga oras ay nasa tuktok ng pagsusuri, at pagkatapos
ito ang mga pangunahing column na tumutukoy kung alin ang tumutukoy sa ulat. Suriin ang "dprofpp" docs para sa
mga detalye ng maraming opsyon na sinusuportahan nito.

Tingnan din ang "Apache::DProf" na nag-hook ng "Devel::DProf" sa "mod_perl".

Devel::Profiler
Tingnan natin ang parehong programa gamit ang ibang profiler: "Devel::Profiler", a
drop-in Perl-only na kapalit para sa "Devel::DProf". Ang paggamit ay medyo naiiba sa
na sa halip na gamitin ang espesyal na "-d:" na bandila, direktang hilahin mo ang "Devel::Profiler" bilang isang
module gamit ang "-M".

$> perl -MDevel::Profiler wordmatch -f perl5db.pl

<...maraming linya ang pinutol...>

ulat ng wordmatch para sa perl5db.pl:
mga linya sa file: 9428
mga salita sa file: 50243
mga salitang may espesyal (hindi salita) na mga character: 20480
mga salitang may mga espesyal na (hindi salita) na mga character lamang: 7790
mga salitang may mga katinig lamang: 4801
mga salitang may malalaking titik lamang: 1316
mga salitang may lamang patinig: 1701

Ang "Devel::Profiler" ay bumubuo ng tmon.out na file na tugma sa "dprofpp"
programa, kaya nai-save ang pagbuo ng isang nakatuong programa sa pagbabasa ng istatistika. "dprofpp"
ang paggamit samakatuwid ay magkapareho sa halimbawa sa itaas.

$> dprofpp

Kabuuang Lumipas na Oras = 20.984 Segundo
Oras ng User+System = 19.981 Segundo
Eksklusibong Panahon
%Time ExclSec CumulS #Calls sec/call Csec/c Name
49.0 9.792 14.509 251215 0.0000 0.0001 pangunahing::mga tugma
24.4 4.887 4.887 260643 0.0000 0.0000 main::debug
0.25 0.049 0.049 1 0.0490 0.0490 pangunahing::ulat
0.00 0.000 0.000 1 0.0000 0.0000 Getopt::Long::GetOptions
0.00 0.000 0.000 2 0.0000 0.0000 Getopt::Long::ParseOptionSpec
0.00 0.000 0.000 1 0.0000 0.0000 Getopt::Long::FindOption
0.00 0.000 0.000 1 0.0000 0.0000 IO::File::bago
0.00 0.000 0.000 1 0.0000 0.0000 IO::Handle::bago
0.00 0.000 0.000 1 0.0000 0.0000 Simbolo::gensym
0.00 0.000 0.000 1 0.0000 0.0000 IO::File::open

Kapansin-pansin na nakakakuha kami ng bahagyang magkakaibang mga resulta, na kadalasan ay dahil sa algorithm
na bumubuo ng ulat ay naiiba, kahit na ang format ng output file ay diumano
magkapareho. Malinaw na ipinapakita ng lumipas, oras ng user at system ang oras na kinuha nito
"Devel::Profiler" upang maisagawa ang sarili nitong pagtakbo, ngunit mas tumpak ang mga listahan ng column
kahit papaano kaysa sa mga nauna namin mula sa "Devel::DPof". Ang 102% na bilang ay mayroon
nawala, halimbawa. Ito ay kung saan kailangan nating gamitin ang mga tool sa ating pagtatapon, at
kilalanin ang kanilang mga kalamangan at kahinaan, bago gamitin ang mga ito. Kapansin-pansin, ang mga bilang ng mga tawag para sa
ang bawat subroutine ay magkapareho sa dalawang ulat, ito ang mga porsyento na naiiba. Bilang
sumulat ang may-akda ng "Devel::Proviler":

...tumatakbo ang HTML::Template's test suite sa ilalim ng Devel::DPof ay nagpapakita ng output()
WALANG oras ngunit ang Devel::Profiler ay nagpapakita sa paligid ng 10% ng oras ay nasa output().
Hindi ko alam kung alin ang dapat kong pagkatiwalaan pero sinasabi sa akin ng puso ko na may mali
Devel::DPof. HTML::Template::output() ay isang malaking routine na kailangan
bawat pagsubok. Alinmang paraan, may kailangang ayusin.

YMMV.

Tingnan din ang "Devel::Apache::Profiler" na nag-hook ng "Devel::Profiler" sa "mod_perl".

Devel::SmallProf
Sinusuri ng "Devel::SmallProf" profiler ang runtime ng iyong Perl program at gumagawa ng
line-by-line na listahan upang ipakita kung gaano karaming beses tinawag ang bawat linya, at gaano katagal ang bawat linya
kinuha upang isagawa. Tinatawag ito sa pamamagitan ng pagbibigay ng pamilyar na flag na "-d" sa Perl sa runtime.

$> perl -d:SmallProf wordmatch -f perl5db.pl

<...maraming linya ang pinutol...>

ulat ng wordmatch para sa perl5db.pl:
mga linya sa file: 9428
mga salita sa file: 50243
mga salitang may espesyal (hindi salita) na mga character: 20480
mga salitang may mga espesyal na (hindi salita) na mga character lamang: 7790
mga salitang may mga katinig lamang: 4801
mga salitang may malalaking titik lamang: 1316
mga salitang may lamang patinig: 1701

Isinulat ng "Devel::SmallProf" ang output nito sa isang file na tinatawag smallprof.out, bilang default. Ang
ang format ng file ay ganito ang hitsura:

:

Kapag natapos na ang programa, maaaring suriin at pag-uri-uriin ang output gamit ang anumang pamantayan
mga kagamitan sa pag-filter ng teksto. Maaaring sapat na ang isang bagay tulad ng sumusunod:

$> pusa smallprof.out | grep \d*: | uri -k3 | tac | ulo -n20

251215 1.65674 7.68000 75: kung ($word =~ /($regex)/ ) {
251215 0.03264 4.40000 79: debug("salita: $i_wd ".($may ? 'matches' :
251215 0.02693 4.10000 81: ibalik ang $has;
260643 0.02841 4.07000 128: kung ($debug) {
260643 0.02601 4.04000 126: my $message = shift;
251215 0.02641 3.91000 73: ang aking $has = 0;
251215 0.03311 3.71000 70: my $i_wd = shift;
251215 0.02699 3.69000 72: my $regex = shift;
251215 0.02766 3.68000 71: my $word = shift;
50243 0.59726 1.00000 59: $count{$i_LINES}{cons} =
50243 0.48175 0.92000 61: $count{$i_LINES}{spec} =
50243 0.00644 0.89000 56: ang aking $i_cons = mga tugma($i_word, $word,
50243 0.48837 0.88000 63: $count{$i_LINES}{caps} =
50243 0.00516 0.88000 58: ang aking $i_caps = mga tugma($i_word, $word, '^[(A-
50243 0.00631 0.81000 54: ang aking $i_spec = mga tugma($i_word, $word, '[^a-
50243 0.00496 0.80000 57: ang aking $i_vows = mga tugma($i_word, $word,
50243 0.00688 0.80000 53: $i_word++;
50243 0.48469 0.79000 62: $count{$i_LINES}{only} =
50243 0.48928 0.77000 60: $count{$i_LINES}{vows} =

50243 0.00683 0.75000 55: ang aking $i_only = mga tugma($i_word, $word, '^[^a-
Makakakita ka kaagad ng bahagyang naiibang pagtutok sa mga subroutine profiling modules,
at nagsisimula kaming makita kung aling linya ng code ang tumatagal ng pinakamaraming oras. Yung regex line
ay mukhang medyo kahina-hinala, halimbawa. Tandaan na ang mga tool na ito ay dapat na
ginamit nang magkasama, walang iisang pinakamahusay na paraan upang i-profile ang iyong code, kailangan mong gamitin ang pinakamahusay
mga kasangkapan para sa trabaho.

Tingnan din ang "Apache::SmallProf" na nag-hook ng "Devel::SmallProf" sa "mod_perl".

Devel::FastProf
Ang "Devel::FastProf" ay isa pang Perl line profiler. Ito ay isinulat na may layuning makuha
isang mas mabilis na line profiler, kaysa sa posible sa halimbawa "Devel::SmallProf", dahil ito ay
nakasulat sa "C". Upang gamitin ang "Devel::FastProf", ibigay ang argumentong "-d" sa Perl:

$> perl -d:FastProf wordmatch -f perl5db.pl

<...maraming linya ang pinutol...>

ulat ng wordmatch para sa perl5db.pl:
mga linya sa file: 9428
mga salita sa file: 50243
mga salitang may espesyal (hindi salita) na mga character: 20480
mga salitang may mga espesyal na (hindi salita) na mga character lamang: 7790
mga salitang may mga katinig lamang: 4801
mga salitang may malalaking titik lamang: 1316
mga salitang may lamang patinig: 1701

Ang "Devel::FastProf" ay nagsusulat ng mga istatistika sa file fastprof.out sa kasalukuyang direktoryo.
Ang output file, na maaaring tukuyin, ay maaaring bigyang-kahulugan sa pamamagitan ng paggamit ng "fprofpp"
programa ng command-line.

$> fprofpp | ulo -n20

# fprofpp output format ay:
# filename:line time count: source
wordmatch:75 3.93338 251215: if ($word =~ /($regex)/ ) {
wordmatch:79 1.77774 251215: debug("word: $i_wd ".($has ? 'matches' : 'does not match')." chars: /$regex/");
wordmatch:81 1.47604 251215: ibalik ang $has;
wordmatch:126 1.43441 260643: my $message = shift;
wordmatch:128 1.42156 260643: if ($debug) {
wordmatch:70 1.36824 251215: my $i_wd = shift;
wordmatch:71 1.36739 251215: my $word = shift;
wordmatch:72 1.35939 251215: my $regex = shift;

Agad na makikita natin na ang bilang ng beses na tinawag ang bawat linya ay magkapareho sa
ang "Devel::SmallProf" na output, at ang pagkakasunud-sunod ay bahagyang naiiba lamang batay sa
ang pagkakasunud-sunod ng tagal ng oras na kinuha ng bawat linya upang maisagawa, "if ($debug ) { " at "my
$message = shift;", halimbawa. Ang mga pagkakaiba sa aktwal na mga oras na naitala ay maaaring nasa
ang algorithm na ginamit sa loob, o maaaring dahil sa mga limitasyon ng mapagkukunan ng system o
pagtatalo.

Tingnan din ang DBIx::Profile na magproprofile ng mga query sa database na tumatakbo sa ilalim ng "DBix::*"
namespace.

Devel::NYTProf
Ang "Devel::NYTProf" ay ang susunod henerasyon ng Perl code profiler, inaayos ang maraming pagkukulang
iba pang mga tool at pagpapatupad ng maraming mga cool na tampok. Una sa lahat maaari itong magamit bilang alinman sa a
linya profiler, a harangan ang o isang subroutine profiler, sabay-sabay. Maaari din itong gumamit ng sub-
microsecond (100ns) resolution sa mga system na nagbibigay ng "clock_gettime()". Maaari itong maging
nagsimula at huminto kahit na sa pamamagitan ng programa na pinoprofile. Isa itong isang linyang entry sa profile
"mod_perl" na mga application. Ito ay nakasulat sa "c" at marahil ang pinakamabilis na profiler
magagamit para sa Perl. Ang listahan ng lamig ay nagpapatuloy. Sapat na, tingnan natin kung paano
gumagana ito - gamitin lang ang pamilyar na switch na "-d" para isaksak ito at patakbuhin ang code.

$> perl -d:NYTProf wordmatch -f perl5db.pl

ulat ng wordmatch para sa perl5db.pl:
mga linya sa file: 9427
mga salita sa file: 50243
mga salitang may espesyal (hindi salita) na mga character: 20480
mga salitang may mga espesyal na (hindi salita) na mga character lamang: 7790
mga salitang may mga katinig lamang: 4801
mga salitang may malalaking titik lamang: 1316
mga salitang may lamang patinig: 1701

Ang "NYTProf" ay bubuo ng database ng ulat sa file nytprof.out bilang default. Tao
Ang mga nababasang ulat ay maaaring mabuo mula dito sa pamamagitan ng paggamit ng ibinigay na "nytprofhtml" (HTML
output) at "nytprofcsv" (CSV output) na mga programa. Ginamit namin ang Unix system na "html2text"
utility para i-convert ang nytprof/index.html file para sa kaginhawahan dito.

$> html2text nytprof/index.html

Index ng Profile ng Pagganap
Para sa wordmatch
Tatakbo noong Biyernes Set 26 13:46:39 2008
Iniulat noong Biyernes Set 26 13:47:23 2008

Nangungunang 15 Subroutine -- inayos ayon sa eksklusibong oras
|Mga Tawag |P |F |Inclusive|Exclusive|Subroutine |
| | | |Oras |Oras | |
|251215|5 |1 |13.09263 |10.47692 |pangunahing:: |mga tugma |
|260642|2 |1 |2.71199 |2.71199 |pangunahing:: |debug |
|1 |1 |1 |0.21404 |0.21404 |pangunahing:: |ulat |
|2 |2 |2 |0.00511 |0.00511 |XSLoader:: |load (xsub) |
|14 |14|7 |0.00304 |0.00298 |Tagaluwas:: |import |
|3 |1 |1 |0.00265 |0.00254 |Tagaluwas:: |bilang_mabigat |
|10 |10|4 |0.00140 |0.00140 |vars:: |import |
|13 |13|1 |0.00129 |0.00109 |constant:: |import |
|1 |1 |1 |0.00360 |0.00096 |FileHandle:: |import |
|3 |3 |3 |0.00086 |0.00074 |mga babala::register::|import |
|9 |3 |1 |0.00036 |0.00036 |mahigpit:: |bits |
|13 |13|13|0.00032 |0.00029 |mahigpit:: |import |
|2 |2 |2 |0.00020 |0.00020 |mga babala:: |import |
|2 |1 |1 |0.00020 |0.00020 |Getopt::Long:: |ParseOptionSpec|
|7 |7 |6 |0.00043 |0.00020 |mahigpit:: |unimport |

Para sa karagdagang impormasyon tingnan ang buong listahan ng 189 subroutine.

Ang unang bahagi ng ulat ay nagpapakita na ng kritikal na impormasyon tungkol sa kung alin
pinakamaraming oras ang ginagamit ng mga subroutine. Ang susunod ay nagbibigay ng ilang istatistika tungkol sa pinagmulan
mga file na naka-profile.

Source Code Files -- inayos ayon sa eksklusibong oras pagkatapos ay pangalan
|Stmts |Eksklusibo|Avg. |Mga Ulat |Source File |
| |Oras | | | |
|2699761|15.66654 |6e-06 |linya . harangan . sub|wordmatch |
|35 |0.02187 |0.00062|linya . harangan . sub|IO/Handle.pm |
|274 |0.01525 |0.00006|linya . harangan . sub|Getopt/Long.pm |
|20 |0.00585 |0.00029|linya . harangan . sub|Fcntl.pm |
|128 |0.00340 |0.00003|linya . harangan . sub|Exporter/Heavy.pm |
|42 |0.00332 |0.00008|linya . harangan . sub|IO/File.pm |
|261 |0.00308 |0.00001|linya . harangan . sub|Exporter.pm |
|323 |0.00248 |8e-06 |linya . harangan . sub|constant.pm |
|12 |0.00246 |0.00021|linya . harangan . sub|File/Spec/Unix.pm |
|191 |0.00240 |0.00001|linya . harangan . sub|vars.pm |
|77 |0.00201 |0.00003|linya . harangan . sub|FileHandle.pm |
|12 |0.00198 |0.00016|linya . harangan . sub|Carp.pm |
|14 |0.00175 |0.00013|linya . harangan . sub|Simbolo.pm |
|15 |0.00130 |0.00009|linya . harangan . sub|IO.pm |
|22 |0.00120 |0.00005|linya . harangan . sub|IO/Seekable.pm |
|198 |0.00085 |4e-06 |linya . harangan . sub|mga babala/register.pm|
|114 |0.00080 |7e-06 |linya . harangan . sub|strict.pm |
|47 |0.00068 |0.00001|linya . harangan . sub|babala.pm |
|27 |0.00054 |0.00002|linya . harangan . sub|overload.pm |
|9 |0.00047 |0.00005|linya . harangan . sub|SelectSaver.pm |
|13 |0.00045 |0.00003|linya . harangan . sub|File/Spec.pm |
|2701595|15.73869 | |Kabuuan |
|128647 |0.74946 | |Karaniwan |
| |0.00201 |0.00003|Median |
| |0.00121 |0.00003|Paglihis |

Ulat na ginawa ng NYTProf 2.03 Perl profiler, na binuo ni Tim Bunce at
Adam Kaplan.

Sa puntong ito, kung ginagamit mo ang html ulat, maaari kang mag-click sa iba't ibang mga link patungo sa
iniutos sa bawat subroutine at bawat linya ng code. Dahil ginagamit namin ang teksto
pag-uulat dito, at mayroong isang buong direktoryo na puno ng mga ulat na binuo para sa bawat source file,
ipapakita lang namin ang isang bahagi ng kaukulang wordmatch-line.html file, sapat sa
magbigay ng ideya ng uri ng output na maaari mong asahan mula sa cool na tool na ito.

$> html2text nytprof/wordmatch-line.html

Profile ng Pagganap -- -block view-.-line view-.-sub view-
Para sa wordmatch
Tatakbo noong Biyernes Set 26 13:46:39 2008
Iniulat noong Biyernes Set 26 13:47:22 2008

File wordmatch

Mga subroutine -- inayos ayon sa eksklusibong oras
|Mga Tawag |P|F|Kabilang|Eksklusibo|Subroutine |
| | | |Oras |Oras | |
|251215|5|1|13.09263 |10.47692 |main::|matches|
|260642|2|1|2.71199 |2.71199 |pangunahing::|debug |
|1 |1|1|0.21404 |0.21404 |pangunahing::|ulat |
|0 |0|0|0 |0 |pangunahing::|SIMULA |

|Line|Stmts.|Eksklusibo|Avg. |Code |
| | |Oras | | |
|1 | | | |#!/usr/bin/perl |
|2 | | | | |
| | | | |gumamit ng mahigpit; |
|3 |3 |0.00086 |0.00029|# ang gumugol ng 0.00003s sa paggawa ng 1 tawag sa mahigpit:: |
| | | | |import |
| | | | |gumamit ng mga babala; |
|4 |3 |0.01563 |0.00521|# ang gumugol ng 0.00012s sa paggawa ng 1 tawag sa mga babala:: |
| | | | |import |
|5 | | | | |
|6 | | | |=head1 PANGALAN |
|7 | | | | |
|8 | | | |filewords - pagsusuri ng salita ng input file |
<...snip...>
|62 |1 |0.00445 |0.00445|print na ulat( %count ); |
| | | | |# ay gumugol ng 0.21404s sa paggawa ng 1 tawag sa main::report|
|63 | | | | |
| | | | |# ang gumastos ng 23.56955s (10.47692+2.61571) sa loob ng |
| | | | |main::matches na tinawag na 251215 beses, |
| | | | |avg 0.00005s/tawag: # 50243 beses |
| | | | |(2.12134+0.51939s) sa linya 57 ng wordmatch, avg|
| | | | |0.00005s/call # 50243 beses (2.17735+0.54550s) |
|64 | | | |sa linya 56 ng wordmatch, avg 0.00005s/call # |
| | | | |50243 beses (2.10992+0.51797s) sa linya 58 ng |
| | | | |wordmatch, avg 0.00005s/call # 50243 beses |
| | | | |(2.12696+0.51598s) sa linya 55 ng wordmatch, avg|
| | | | |0.00005s/call # 50243 beses (1.94134+0.51687s) |
| | | | |sa linya 54 ng wordmatch, avg 0.00005s/tawag |
| | | | |sub na mga tugma { |
<...snip...>
|102 | | | | |
| | | | |# ay gumugol ng 2.71199s sa loob ng main::debug na |
| | | | |tumawag ng 260642 beses, avg 0.00001s/tawag: # |
| | | | |251215 beses (2.61571+0s) ayon sa pangunahing::mga tugma sa |
|103 | | | |line 74 ng wordmatch, avg 0.00001s/call # 9427 |
| | | | |beses (0.09628+0s) sa line 50 ng wordmatch, avg|
| | | | |0.00001s/tawag |
| | | | |sub debug { |
|104 |260642|0.58496 |2e-06 |my $message = shift; |
|105 | | | | |
|106 |260642|1.09917 |4e-06 |if ($debug ) { |
|107 | | | |print STDERR "DBG: $message\n"; |
|108 | | | |} |
|109 | | | |} |
|110 | | | | |
|111 |1 |0.01501 |0.01501|lumabas 0; |
|112 | | | | |

Napakaraming kapaki-pakinabang na impormasyon doon - tila ito ang daan pasulong.

Tingnan din ang "Devel::NYTProf::Apache" na nag-hook ng "Devel::NYTProf" sa "mod_perl".

PAG-UURI

Ang mga module ng Perl ay hindi lamang ang mga tool na mayroon ang isang performance analyst sa kanilang pagtatapon, system
Ang mga tool tulad ng "oras" ay hindi dapat palampasin gaya ng ipinapakita ng susunod na halimbawa, kung saan kami kumukuha ng a
mabilis na pagtingin sa pag-uuri. Maraming mga libro, tesis at artikulo, ang naisulat tungkol sa mahusay
pag-uuri ng mga algorithm, at hindi ito ang lugar para ulitin ang ganoong gawain, mayroong maraming mabuti
pag-uuri ng mga module na karapat-dapat na tingnan din: "Pagbukud-bukurin::Maker", "Pag-uri-uriin::Susi" tagsibol hanggang
isip. Gayunpaman, posible pa ring gumawa ng ilang mga obserbasyon sa ilang partikular na Perl
mga interpretasyon sa mga isyung nauugnay sa pag-uuri ng mga set ng data at magbigay ng isang halimbawa o dalawa sa
tungkol sa kung paano makakaapekto sa pagganap ang pag-uuri ng malalaking volume ng data. Una, madalas
overlooked point kapag nag-uuri ng malalaking halaga ng data, maaaring subukan ng isa na bawasan ang data
itinakda upang harapin at sa maraming mga kaso ang "grep()" ay maaaring maging kapaki-pakinabang bilang isang simpleng filter:

@data = sort grep { /$filter/ } @incoming

Ang isang utos na tulad nito ay maaaring lubos na mabawasan ang dami ng materyal na aktwal na ayusin
sa unang lugar, at hindi dapat masyadong basta-basta ipagwalang-bahala na puro batayan nito
pagiging simple. Ang prinsipyong "KISS" ay masyadong madalas na napapansin - ang susunod na halimbawa ay gumagamit ng
simpleng sistema "oras" utility upang ipakita. Tingnan natin ang isang aktwal na halimbawa ng
pag-uuri ng mga nilalaman ng isang malaking file, gagawin ng isang apache logfile. Ang isang ito ay may higit sa isang
quarter ng isang milyong linya, ay 50M ang laki, at ganito ang hitsura ng isang snippet nito:

# logfile

188.209-65-87.adsl-dyn.isp.belgacom.be - - [08/Feb/2007:12:57:16 +0000] "GET /favicon.ico HTTP/1.1" 404 209 "-" "Mozilla/ 4.0 (katugma; MSIE 6.0; Windows NT 5.1; SV1)"
188.209-65-87.adsl-dyn.isp.belgacom.be - - [08/Feb/2007:12:57:16 +0000] "GET /favicon.ico HTTP/1.1" 404 209 "-" "Mozilla/ 4.0 (katugma; MSIE 6.0; Windows NT 5.1; SV1)"
151.56.71.198 - - [08/Feb/2007:12:57:41 +0000] "GET /suse-on-vaio.html HTTP/1.1" 200 2858 "http://www.linux-on-laptops.com/sony.html" "Mozilla/5.0 (Windows; U; Windows NT 5.2; en-US; rv:1.8.1.1) Gecko/20061204 Firefox/2.0.0.1"
151.56.71.198 - - [08/Feb/2007:12:57:42 +0000] "KUMUHA /data/css HTTP/1.1" 404 206 "http://www.rfi.net/suse-on-vaio.html" "Mozilla/5.0 (Windows; U; Windows NT 5.2; en-US; rv:1.8.1.1) Gecko/20061204 Firefox/2.0.0.1"
151.56.71.198 - - [08/Feb/2007:12:57:43 +0000] "GET /favicon.ico HTTP/1.1" 404 209 "-" "Mozilla/5.0 (Windows; U; Windows NT 5.2; en- US; rv:1.8.1.1) Tuko/20061204 Firefox/2.0.0.1"
217.113.68.60 - - [08/Feb/2007:13:02:15 +0000] "GET / HTTP/1.1" 304 - "-" "Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1; SV1)"
217.113.68.60 - - [08/Feb/2007:13:02:16 +0000] "KUMUHA /data/css HTTP/1.1" 404 206 "http://www.rfi.net/" "Mozilla/4.0 (katugma; MSIE 6.0; Windows NT 5.1; SV1)"
debora.to.isac.cnr.it - ​​- [08/Feb/2007:13:03:58 +0000] "GET /suse-on-vaio.html HTTP/1.1" 200 2858 "http://www.linux-on-laptops.com/sony.html" "Mozilla/5.0 (katugma; Konqueror/3.4; Linux) KHTML/3.4.0 (tulad ng Tuko)"
debora.to.isac.cnr.it - ​​- [08/Feb/2007:13:03:58 +0000] "GET /data/css HTTP/1.1" 404 206 "http://www.rfi.net/suse-on-vaio.html" "Mozilla/5.0 (katugma; Konqueror/3.4; Linux) KHTML/3.4.0 (tulad ng Tuko)"
debora.to.isac.cnr.it - ​​- [08/Feb/2007:13:03:58 +0000] "GET /favicon.ico HTTP/1.1" 404 209 "-" "Mozilla/5.0 (compatible; Konqueror/ 3.4; Linux) KHTML/3.4.0 (tulad ng Tuko)"
195.24.196.99 - - [08/Feb/2007:13:26:48 +0000] "GET / HTTP/1.0" 200 3309 "-" "Mozilla/5.0 (Windows; U; Windows NT 5.1; fr; rv:1.8.0.9 .20061206) Tuko/1.5.0.9 Firefox/XNUMX"
195.24.196.99 - - [08/Feb/2007:13:26:58 +0000] "KUMUHA /data/css HTTP/1.0" 404 206 "http://www.rfi.net/" "Mozilla/5.0 (Windows; U; Windows NT 5.1; fr; rv:1.8.0.9) Tuko/20061206 Firefox/1.5.0.9"
195.24.196.99 - - [08/Feb/2007:13:26:59 +0000] "GET /favicon.ico HTTP/1.0" 404 209 "-" "Mozilla/5.0 (Windows; U; Windows NT 5.1; fr; rv:1.8.0.9) Tuko/20061206 Firefox/1.5.0.9"
crawl1.cosmixcorp.com - - [08/Feb/2007:13:27:57 +0000] "GET /robots.txt HTTP/1.0" 200 179 "-" "voyager/1.0"
crawl1.cosmixcorp.com - - [08/Feb/2007:13:28:25 +0000] "GET /links.html HTTP/1.0" 200 3413 "-" "voyager/1.0"
fhm226.internetdsl.tpnet.pl - - [08/Feb/2007:13:37:32 +0000] "GET /suse-on-vaio.html HTTP/1.1" 200 2858 "http://www.linux-on-laptops.com/sony.html" "Mozilla/4.0 (katugma; MSIE 6.0; Windows NT 5.1; SV1)"
fhm226.internetdsl.tpnet.pl - - [08/Feb/2007:13:37:34 +0000] "GET /data/css HTTP/1.1" 404 206 "http://www.rfi.net/suse-on-vaio.html" "Mozilla/4.0 (katugma; MSIE 6.0; Windows NT 5.1; SV1)"
80.247.140.134 - - [08/Feb/2007:13:57:35 +0000] "GET / HTTP/1.1" 200 3309 "-" "Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1 ; .NET CLR .1.1.4322)"
80.247.140.134 - - [08/Feb/2007:13:57:37 +0000] "KUMUHA /data/css HTTP/1.1" 404 206 "http://www.rfi.net" "Mozilla/4.0 (tugma; MSIE 6.0; Windows NT 5.1; .NET CLR 1.1.4322)"
pop.compuscan.co.za - - [08/Feb/2007:14:10:43 +0000] "GET / HTTP/1.1" 200 3309 "-" "www.clamav.net"
livebot-207-46-98-57.search.live.com - - [08/Feb/2007:14:12:04 +0000] "GET /robots.txt HTTP/1.0" 200 179 "-" "msnbot/ 1.0 (+http://search.msn.com/msnbot.htm)"
livebot-207-46-98-57.search.live.com - - [08/Feb/2007:14:12:04 +0000] "GET /html/oracle.html HTTP/1.0" 404 214 "-" " msnbot/1.0 (+http://search.msn.com/msnbot.htm)"
dslb-088-064-005-154.pools.arcor-ip.net - - [08/Feb/2007:14:12:15 +0000] "GET / HTTP/1.1" 200 3309 "-" "www.clamav .net"
196.201.92.41 - - [08/Feb/2007:14:15:01 +0000] "GET / HTTP/1.1" 200 3309 "-" "MOT-L7/08.B7.DCR MIB/2.2.1 Profile/MIDP -2.0 Configuration/CLDC-1.1"

Ang partikular na gawain dito ay pag-uri-uriin ang 286,525 na linya ng file na ito ayon sa Response Code, Query,
Browser, Nagre-refer na Url, at panghuli Petsa. Ang isang solusyon ay maaaring gamitin ang sumusunod na code,
na umuulit sa mga file na ibinigay sa command-line.

# sort-apache-log

#!/usr/bin/perl -n

gumamit ng mahigpit;
gumamit ng mga babala;

ang aking data;

Linya:
habang ( <> ) {
aking $line = $_;
kung (
$line =~ m/^(
([\w\.\-]+) # client
\s*-\s*-\s*\[
([^]]+) # petsa
\]\s*"\w+\s*
(\S+) # query
[^"]+"\s*
(\d+) # status
\s+\S+\s+"[^"]*"\s+"
([^"]*) # browser
"
.*
)$/x
) {
my @chunks = split(/ +/, $line);
aking $ip = $1;
aking $date = $2;
ang aking $query = $3;
ang aking $status = $4;
aking $browser = $5;

push(@data, [$ip, $date, $query, $status, $browser, $line]);
}
}

aking @sorted = sort {
$a->[3] cmp $b->[3]
||
$a->[2] cmp $b->[2]
||
$a->[0] cmp $b->[0]
||
$a->[1] cmp $b->[1]
||
$a->[4] cmp $b->[4]
} @data;

foreach aking $data ( @sorted ) {
i-print ang $data->[5];
}

exit 0;

Kapag pinapatakbo ang program na ito, i-redirect ang "STDOUT" upang masuri ang output
tama mula sa mga sumusunod na pagsubok na tumatakbo at gamitin ang sistema ng "oras" utility upang suriin ang pangkalahatang
runtime.

$> oras ./sort-apache-log logfile > out-sort

aktwal na 0m17.371s
gumagamit 0m15.757s
sys 0m0.592s

Ang programa ay tumagal lamang ng higit sa 17 wallclock segundo upang tumakbo. Pansinin ang iba't ibang halaga na "oras"
output, mahalagang palaging gamitin ang pareho, at hindi malito kung ano ang bawat isa
Nangangahulugan.

Lumipas na Tunay na Oras
Ang pangkalahatang, o wallclock, oras sa pagitan ng kung kailan tinawag ang "oras", at kung kailan ito
nagtatapos. Kasama sa lumipas na oras ang parehong oras ng user at system, at oras na ginugol
naghihintay para sa iba pang mga gumagamit at mga proseso sa system. Hindi maiiwasan, ito ang pinaka
tinatayang mga sukat na ibinigay.

Oras ng CPU ng Gumagamit
Ang oras ng user ay ang dami ng oras na ginugol ng buong proseso sa ngalan ng user
ang sistemang ito na nagpapatupad ng programang ito.

Oras ng System CPU
Ang oras ng system ay ang dami ng oras na ginugol mismo ng kernel sa pagsasagawa ng mga gawain, o
mga tawag sa system, sa ngalan ng user ng prosesong ito.

Ang pagpapatakbo ng parehong proseso bilang isang "Schwarzian Transform" ay posibleng alisin ang
input at output array para sa pag-iimbak ng lahat ng data, at gumana sa input nang direkta tulad nito
dumating din. Kung hindi, ang code ay mukhang medyo katulad:

# sort-apache-log-schwarzian

#!/usr/bin/perl -n

gumamit ng mahigpit;
gumamit ng mga babala;

i-print

mapa $_->[0] =>

uri {
$a->[4] cmp $b->[4]
||
$a->[3] cmp $b->[3]
||
$a->[1] cmp $b->[1]
||
$a->[2] cmp $b->[2]
||
$a->[5] cmp $b->[5]
}
mapa [ $_, m/^(
([\w\.\-]+) # client
\s*-\s*-\s*\[
([^]]+) # petsa
\]\s*"\w+\s*
(\S+) # query
[^"]+"\s*
(\d+) # status
\s+\S+\s+"[^"]*"\s+"
([^"]*) # browser
"
.*
)$/xo ]

=> <>;

exit 0;

Patakbuhin ang bagong code laban sa parehong logfile, tulad ng nasa itaas, upang suriin ang bagong oras.

$> oras ./sort-apache-log-schwarzian logfile > out-schwarz

aktwal na 0m9.664s
gumagamit 0m8.873s
sys 0m0.704s

Ang oras ay pinutol sa kalahati, na isang kagalang-galang na pagpapabuti ng bilis ng anumang pamantayan.
Naturally, mahalagang suriin ang output ay pare-pareho sa unang pagtakbo ng programa,
ito ay kung saan ang Unix system "cksum" utility ay pumapasok.

$> cksum out-sort out-schwarz
3044173777 52029194 out-sort
3044173777 52029194 out-schwarz

BTW. Mag-ingat din sa panggigipit ng mga manager na nakakakita sa iyo na mapabilis ang isang programa ng 50% ng
runtime nang isang beses, para lamang makakuha ng kahilingan makalipas ang isang buwan na gawin ang parehong muli (true story) -
kailangan mo lang ituro na ikaw ay tao lamang, kahit na ikaw ay isang Perl programmer, at
makikita mo kung ano ang magagawa mo...

PAGTOTROSO

Ang isang mahalagang bahagi ng anumang mahusay na proseso ng pag-unlad ay ang naaangkop na paghawak ng error
naaangkop na mga mensaheng nagbibigay-kaalaman, gayunpaman mayroong isang paaralan ng pag-iisip na
nagmumungkahi na ang mga log file ay dapat na chatty, na parang ang kadena ng walang patid na output kahit papaano
tinitiyak ang kaligtasan ng programa. Kung ang bilis ay sa anumang paraan ay isang isyu, ang diskarte na ito ay
mali.

Ang isang karaniwang paningin ay ang code na mukhang ganito:

logger->debug( "Isang mensahe sa pag-log sa pamamagitan ng process-id: $$ INC: " . Dumper(\%INC) )

Ang problema ay ang code na ito ay palaging ipapa-parse at isasagawa, kahit na ang pag-debug
Ang antas na itinakda sa logging configuration file ay zero. Sa sandaling ang debug() naging subroutine
ipinasok, at ang panloob na $debug variable ay nakumpirma na zero, halimbawa, ang mensahe
na ipinadala ay itatapon at ang programa ay magpapatuloy. Sa halimbawa
na ibinigay gayunpaman, ang "\%INC" hash ay nai-dump na, at ang string ng mensahe
constructed, ang lahat ng trabaho ay maaaring ma-bypass ng isang debug variable sa statement
antas, tulad nito:

logger->debug( "Isang mensahe sa pag-log sa pamamagitan ng process-id: $$ INC: " . Dumper(\%INC) ) kung $DEBUG;

Ang epektong ito ay maaaring ipakita sa pamamagitan ng pag-set up ng isang test script na may parehong mga form, kabilang ang a
"debug()" subroutine para tularan ang tipikal na "logger()" functionality.

# ifdebug

#!/usr/bin/perl

gumamit ng mahigpit;
gumamit ng mga babala;

gumamit ng Benchmark;
gumamit ng Data::Dumper;
aking $DEBUG = 0;

sub debug {
aking $msg = shift;

kung ($DEBUG) {
i-print ang "DEBUG: $msg\n";
}
};

timethese(100000, {
'debug' => sub {
debug( "Isang $0 logging message sa pamamagitan ng process-id: $$" . Dumper(\%INC) )
},
'ifdebug' => sub {
debug( "Isang $0 logging message sa pamamagitan ng process-id: $$" . Dumper(\%INC) ) kung $DEBUG
},
});

Tingnan natin kung ano ang ginagawa ng "Benchmark" dito:

$> perl ifdebug
Benchmark: timing ng 100000 na pag-ulit ng pare-pareho, sub...
ifdebug: 0 wallclock seg ( 0.01 usr + 0.00 sys = 0.01 CPU) @ 10000000.00/s (n=100000)
(babala: masyadong kaunting mga pag-ulit para sa isang maaasahang bilang)
debug: 14 wallclock seg (13.18 usr + 0.04 sys = 13.22 CPU) @ 7564.30/s (n=100000)

Sa isang kaso ang code, na gumagawa ng eksaktong parehong bagay hangga't naglalabas ng anuman
Ang impormasyon sa pag-debug ay nababahala, sa madaling salita wala, tumatagal ng 14 na segundo, at sa
ibang kaso ang code ay tumatagal ng isang daan ng isang segundo. Mukhang medyo definitive. Gumamit ng a
$DEBUG variable BAGO mo tawagan ang subroutine, sa halip na umasa sa matalino
functionality sa loob nito.

Pagtotroso if MGA DEBUG (pare-pareho)
Posibleng gawin ang nakaraang ideya nang kaunti pa, sa pamamagitan ng paggamit ng oras ng pag-compile na "DEBUG"
pare-pareho.

# ifdebug-constant

#!/usr/bin/perl

gumamit ng mahigpit;
gumamit ng mga babala;

gumamit ng Benchmark;
gumamit ng Data::Dumper;
gumamit ng pare-pareho
DEBUG => 0
;

sub debug {
kung ( DEBUG ) {
aking $msg = shift;
i-print ang "DEBUG: $msg\n";
}
};

timethese(100000, {
'debug' => sub {
debug( "Isang $0 logging message sa pamamagitan ng process-id: $$" . Dumper(\%INC) )
},
'constant' => sub {
debug( "Isang $0 logging message sa pamamagitan ng process-id: $$" . Dumper(\%INC) ) kung DEBUG
},
});

Ang pagpapatakbo ng program na ito ay gumagawa ng sumusunod na output:

$> perl ifdebug-constant
Benchmark: timing ng 100000 na pag-ulit ng pare-pareho, sub...
pare-pareho: 0 wallclock seg (-0.00 usr + 0.00 sys = -0.00 CPU) @ -7205759403792793600000.00/s (n=100000)
(babala: masyadong kaunting mga pag-ulit para sa isang maaasahang bilang)
sub: 14 wallclock seg (13.09 usr + 0.00 sys = 13.09 CPU) @ 7639.42/s (n=100000)

Pinupunasan ng pare-parehong "DEBUG" ang sahig kahit na ang variable na $debug, na umaabot sa minus
zero segundo, at bumubuo ng isang "babala: masyadong kaunting mga pag-ulit para sa isang maaasahang bilang" na mensahe
sa pangangalakal. Upang makita kung ano talaga ang nangyayari, at kung bakit nagkaroon kami ng napakakaunting mga pag-ulit kung kailan
naisip namin na humingi kami ng 100000, magagamit namin ang napaka-kapaki-pakinabang na "B::Deparse" upang suriin ang bagong
code:

$> perl -MO=Deparse ifdebug-constant

gumamit ng Benchmark;
gumamit ng Data::Dumper;
gumamit ng pare-pareho ('DEBUG', 0);
sub debug {
gumamit ng mga babala;
gumamit ng mahigpit na 'ref';
0;
}
gumamit ng mga babala;
gumamit ng mahigpit na 'ref';
timethese(100000, {'sub', sub {
debug "Isang $0 logging message sa pamamagitan ng process-id: $$" . Dumper(\%INC);
}
, 'pare-pareho', sub {
0;
}
});
ifdebug-constant syntax OK

Ang output ay nagpapakita ng pare-pareho() subroutine na sinusubok namin na pinapalitan ng halaga ng
ang pare-parehong "DEBUG": zero. Ang linyang susuriin ay ganap na na-optimize, at
hindi ka makakakuha ng mas mahusay kaysa doon.

POSTSCRIPT

Ang dokumentong ito ay nagbigay ng ilang paraan upang matukoy ang mga hot-spot, at pagsuri
kung napabuti ng anumang mga pagbabago ang runtime ng code.

Bilang pangwakas na pag-iisip, tandaan na hindi (sa oras ng pagsulat) posibleng makagawa ng a
kapaki-pakinabang na programa na tatakbo sa zero o negatibong oras at ang pangunahing prinsipyong ito ay maaaring
nakasulat bilang: kapaki-pakinabang mga programa ay pabagalin sa mismong kahulugan nila. Ito ay siyempre posible
na magsulat ng halos agad-agad na programa, ngunit hindi ito gaanong magagawa, narito ang isang napaka
mabisa:

$> perl -e 0

Ang pag-optimize na ang anumang karagdagang ay isang trabaho para sa "p5p".

Gumamit ng perlperf online gamit ang mga serbisyo ng onworks.net