perlperf - ອອນລາຍໃນຄລາວ

ແລ່ນ perlperf ໃນ OnWorks ຜູ້ໃຫ້ບໍລິການໂຮດຕິ້ງຟຣີຜ່ານ Ubuntu Online, Fedora Online, Windows online emulator ຫຼື MAC OS online emulator

ນີ້ແມ່ນຄໍາສັ່ງ perlperf ທີ່ສາມາດດໍາເນີນການໄດ້ໃນ OnWorks ຜູ້ໃຫ້ບໍລິການໂຮດຕິ້ງຟຣີໂດຍໃຊ້ຫນຶ່ງໃນຫຼາຍບ່ອນເຮັດວຽກອອນໄລນ໌ຂອງພວກເຮົາເຊັ່ນ Ubuntu Online, Fedora Online, Windows online emulator ຫຼື MAC OS online emulator

ແລ່ນໃນ Ubuntu ດໍາເນີນການໃນ Fedora ດໍາເນີນການໃນ Windows Sim ແລ່ນໃນ MACOS Sim

ໂຄງການ:

NAME

perlperf - ເຕັກນິກການປະຕິບັດແລະການເພີ່ມປະສິດທິພາບຂອງ Perl

ລາຍລະອຽດ

ນີ້ແມ່ນການແນະນໍາການນໍາໃຊ້ເຕັກນິກການປະຕິບັດແລະການເພີ່ມປະສິດທິພາບທີ່ສາມາດເປັນ
ນໍາໃຊ້ກັບການອ້າງອີງໂດຍສະເພາະກັບໂຄງການ perl. ໃນຂະນະທີ່ນັກພັດທະນາ perl ຫຼາຍຄົນໄດ້ມາ
ຈາກພາສາອື່ນ, ແລະສາມາດນໍາໃຊ້ຄວາມຮູ້ເບື້ອງຕົ້ນຂອງເຂົາເຈົ້າຕາມຄວາມເຫມາະສົມ, ມີຫຼາຍ
ຄົນອື່ນໆທີ່ອາດຈະໄດ້ຮັບຜົນປະໂຫຍດຈາກຕົວຊີ້ສະເພາະ perl ຈໍານວນຫນ້ອຍ. ຖ້າທ່ານຕ້ອງການ
ສະບັບ condensed, ບາງທີຄໍາແນະນໍາທີ່ດີທີ່ສຸດແມ່ນມາຈາກ Samurai ຍີ່ປຸ່ນທີ່ມີຊື່ສຽງ,
Miyamoto Musashi, ຜູ້ທີ່ເວົ້າວ່າ:

"ຢ່າມີສ່ວນຮ່ວມໃນກິດຈະກໍາທີ່ບໍ່ມີປະໂຫຍດ"

ໃນ 1645.

ພາບລວມ

ບາງທີຄວາມຜິດພາດທົ່ວໄປທີ່ສຸດທີ່ນັກຂຽນໂປລແກລມເຮັດແມ່ນເພື່ອພະຍາຍາມເພີ່ມປະສິດທິພາບລະຫັດຂອງພວກເຂົາ
ກ່ອນທີ່ໂຄງການຈະເຮັດຫຍັງທີ່ເປັນປະໂຫຍດ - ນີ້ແມ່ນຄວາມຄິດທີ່ບໍ່ດີ. ບໍ່ມີຈຸດຢູ່ໃນ
ມີໂຄງການໄວທີ່ສຸດທີ່ບໍ່ເຮັດວຽກ. ວຽກທໍາອິດແມ່ນເພື່ອເອົາໂຄງການ
ຢ່າງຖືກຕ້ອງ ເຮັດບາງສິ່ງບາງຢ່າງ ທີ່ເປັນປະໂຫຍດ, (ບໍ່ໄດ້ກ່າວເຖິງການຮັບປະກັນຊຸດການທົດສອບແມ່ນຢ່າງເຕັມທີ່
functional), ແລະພຽງແຕ່ຫຼັງຈາກນັ້ນເພື່ອພິຈາລະນາ optimizing ມັນ. ມີການຕັດສິນໃຈທີ່ຈະເພີ່ມປະສິດທິພາບທີ່ມີຢູ່ແລ້ວ
ລະຫັດການເຮັດວຽກ, ມີຫຼາຍຂັ້ນຕອນທີ່ງ່າຍດາຍແຕ່ສໍາຄັນທີ່ຈະພິຈາລະນາທີ່ເປັນພາຍໃນ
ກັບຂະບວນການເພີ່ມປະສິດທິພາບໃດໆ.

ONE ຂັ້ນຕອນທີ ຂ້າງທາງ
ກ່ອນອື່ນ ໝົດ, ທ່ານ ຈຳ ເປັນຕ້ອງ ກຳ ນົດເວລາພື້ນຖານ ສຳ ລັບລະຫັດທີ່ມີຢູ່, ເຊິ່ງຕ້ອງການເວລາ
ມີຄວາມໜ້າເຊື່ອຖື ແລະ ສາມາດເຮັດຊ້ຳໄດ້. ທ່ານອາດຈະຕ້ອງການໃຊ້ "Benchmark" ຫຼື
ໂມດູນ "Devel::NYTProf", ຫຼືບາງສິ່ງບາງຢ່າງທີ່ຄ້າຍຄືກັນ, ສໍາລັບຂັ້ນຕອນນີ້, ຫຼືບາງທີລະບົບ Unix.
"ເວລາ" ຜົນປະໂຫຍດ, ອັນໃດກໍ່ຕາມທີ່ເຫມາະສົມ. ເບິ່ງພື້ນຖານຂອງເອກະສານນີ້ສໍາລັບບັນຊີລາຍຊື່ທີ່ຍາວກວ່າ
ຂອງ benchmarking ແລະໂມດູນ profileing, ແລະແນະນໍາໃຫ້ອ່ານເພີ່ມເຕີມ.

ONE ຂັ້ນຕອນທີ FORWARD
ຕໍ່ໄປ, ໄດ້ກວດກາໂຄງການສໍາລັບ ຮ້ອນ ຈຸດຕ່າງໆ, (ສະຖານທີ່ທີ່ລະຫັດເບິ່ງຄືວ່າຈະດໍາເນີນການ
ຊ້າ), ປ່ຽນລະຫັດດ້ວຍຄວາມຕັ້ງໃຈທີ່ຈະເຮັດໃຫ້ມັນແລ່ນໄວຂຶ້ນ. ການນໍາໃຊ້ສະບັບ
ຊອບແວການຄວບຄຸມ, ເຊັ່ນ: "ການໂຄ່ນລົ້ມ" ຈະຮັບປະກັນວ່າບໍ່ມີການປ່ຽນແປງທີ່ບໍ່ມີການປ່ຽນແປງໄດ້. ມັນຄືກັນ
ງ່າຍທີ່ຈະ fiddle ທີ່ນີ້ແລະ fiddle ຢູ່ທີ່ນັ້ນ - ຢ່າປ່ຽນແປງຫຼາຍເກີນໄປໃນເວລາດຽວຫຼືທ່ານອາດຈະ
ບໍ່ຄົ້ນພົບວ່າລະຫັດໃດ ກໍ່ ເປັນການຊ້າ.

ຄົນອື່ນ ຂັ້ນຕອນທີ ຂ້າງທາງ
ມັນບໍ່ພຽງພໍທີ່ຈະເວົ້າວ່າ: "ທີ່ຈະເຮັດໃຫ້ມັນແລ່ນໄວ", ທ່ານຕ້ອງກວດເບິ່ງມັນ. ແລ່ນຄືນໃໝ່
ລະຫັດພາຍໃຕ້ການຄວບຄຸມຂອງ benchmarking ຫຼືໂມດູນ profileing, ຈາກຂັ້ນຕອນທໍາອິດຂ້າງເທິງ,
ແລະກວດເບິ່ງວ່າລະຫັດໃຫມ່ໄດ້ດໍາເນີນການ ດຽວກັນ ວຽກງານ in ຫນ້ອຍ ທີ່ໃຊ້ເວລາ. ຊ່ວຍປະຢັດການເຮັດວຽກຂອງທ່ານແລະ
ຊ້ຳ...

ທົ່ວໄປ GUIDELINES

ສິ່ງທີ່ສໍາຄັນໃນເວລາທີ່ພິຈາລະນາການປະຕິບັດແມ່ນເພື່ອຈື່ຈໍາວ່າບໍ່ມີສິ່ງດັ່ງກ່າວເປັນ
"Golden Bullet", ນັ້ນແມ່ນເຫດຜົນທີ່ບໍ່ມີກົດລະບຽບ, ພຽງແຕ່ຄໍາແນະນໍາ.

ມັນເປັນທີ່ຊັດເຈນວ່າລະຫັດ inline ຈະໄວກວ່າການເອີ້ນແບບ subroutine ຫຼືວິທີການ,
ເນື່ອງຈາກວ່າມີຄ່າໃຊ້ຈ່າຍຫນ້ອຍ, ແຕ່ວິທີການນີ້ມີຂໍ້ເສຍຂອງຫນ້ອຍ
ຮັກສາໄດ້ແລະມາໃນຄ່າໃຊ້ຈ່າຍຂອງການນໍາໃຊ້ຄວາມຊົງຈໍາຫຼາຍກວ່າເກົ່າ - ບໍ່ມີສິ່ງດັ່ງກ່າວເປັນ
ອາຫານທ່ຽງຟຣີ. ຖ້າທ່ານກໍາລັງຊອກຫາອົງປະກອບໃນບັນຊີລາຍຊື່, ມັນສາມາດມີປະສິດທິພາບຫຼາຍຂຶ້ນ
ເກັບຮັກສາຂໍ້ມູນໄວ້ໃນໂຄງສ້າງ hash, ແລະຫຼັງຈາກນັ້ນພຽງແຕ່ເບິ່ງເພື່ອເບິ່ງວ່າລະຫັດແມ່ນ
ກໍານົດ, ແທນທີ່ຈະ loop ຜ່ານ array ທັງຫມົດໂດຍໃຊ້ grep() ຕົວຢ່າງ. ຍ່ອຍ()
ອາດຈະ (ຫຼາຍ) ໄວກວ່າ grep() ແຕ່ບໍ່ມີຄວາມປ່ຽນແປງໄດ້, ດັ່ງນັ້ນທ່ານມີການແລກປ່ຽນໄປອີກເທື່ອຫນຶ່ງ
ການເຂົ້າເຖິງ. ລະຫັດຂອງທ່ານອາດມີເສັ້ນທີ່ຈະໃຊ້ເວລາ 0.01 ຂອງວິນາທີເພື່ອປະຕິບັດການນັ້ນຖ້າທ່ານ
ໂທຫາມັນ 1,000 ເທື່ອ, ຂ້ອນຂ້າງອາດຈະຢູ່ໃນໂຄງການ parsing ເຖິງແມ່ນວ່າໄຟລ໌ຂະຫນາດກາງສໍາລັບ
ຕົວຢ່າງ, ທ່ານມີການຊັກຊ້າ 10 ວິນາທີແລ້ວ, ຢູ່ໃນສະຖານທີ່ລະຫັດດຽວ, ແລະຖ້າທ່ານ
ໂທຫາສາຍນັ້ນ 100,000 ເທື່ອ, ໂຄງການທັງຫມົດຂອງທ່ານຈະຊ້າລົງກັບການລວບລວມຂໍ້ມູນທີ່ບໍ່ທົນທານ.

ການນໍາໃຊ້ໂຄງການຍ່ອຍເປັນສ່ວນຫນຶ່ງຂອງການຈັດລຽງຂອງທ່ານເປັນວິທີທີ່ມີອໍານາດທີ່ຈະໄດ້ຮັບສິ່ງທີ່ທ່ານຕ້ອງການຢ່າງແທ້ຈິງ,
ແຕ່ປົກກະຕິແລ້ວຈະຊ້າກວ່າການກໍ່ສ້າງໃນ ຕົວອັກສອນ "cmp" ແລະ numeric " <=>" ຄັດ
ຜູ້ປະກອບການ. ມັນເປັນໄປໄດ້ທີ່ຈະເຮັດໃຫ້ຫຼາຍ passes ໃນໄລຍະຂໍ້ມູນຂອງທ່ານ, ຕົວຊີ້ວັດການກໍ່ສ້າງ
ເຮັດໃຫ້ການຈັດລຽງທີ່ຈະມາເຖິງປະສິດທິພາບຫຼາຍຂຶ້ນ, ແລະການນໍາໃຊ້ທີ່ຮູ້ຈັກເປັນ "OM" (Orcish
Maneuver) ເພື່ອ cache ລະຫັດການຈັດລຽງລ່ວງຫນ້າ. ການຄົ້ນຫາຖານຄວາມຈໍາ, ໃນຂະນະທີ່ເປັນຄວາມຄິດທີ່ດີ, ສາມາດ
ຕົວຂອງມັນເອງເປັນແຫຼ່ງຂອງການຊ້າລົງໂດຍການບັງຄັບໃຫ້ຜ່ານຂໍ້ມູນສອງຄັ້ງ - ການຕິດຕັ້ງຄັ້ງດຽວ
cache, ແລະຄັ້ງດຽວເພື່ອຈັດຮຽງຂໍ້ມູນ. ການນໍາໃຊ້ "pack()" ເພື່ອດຶງອອກຄໍາຖາມການຄັດເລືອກທີ່ຕ້ອງການ
ເຂົ້າໄປໃນສະຕຣິງທີ່ສອດຄ່ອງສາມາດເປັນວິທີທີ່ມີປະສິດທິພາບໃນການສ້າງສາຍດຽວເພື່ອປຽບທຽບ,
ແທນທີ່ຈະໃຊ້ລະຫັດການຈັດລຽງຫຼາຍ, ເຊິ່ງເຮັດໃຫ້ມັນສາມາດນໍາໃຊ້ມາດຕະຖານ, ລາຍລັກອັກສອນ
ໃນ "c" ແລະໄວ, perl "sort()" ຟັງຊັນກ່ຽວກັບຜົນຜະລິດ, ແລະເປັນພື້ນຖານຂອງ "GRT"
(Guttman Rossler Transform). ການປະສົມສາຍບາງສາມາດເຮັດໃຫ້ "GRT" ຊ້າລົງ, ພຽງແຕ່
ເປັນສະລັບສັບຊ້ອນທົ່ງພຽງເກີນໄປສໍາລັບການດີຂອງຕົນ.

ສໍາລັບແອັບພລິເຄຊັນທີ່ໃຊ້ backends ຖານຂໍ້ມູນ, namespace "DBIx" ມາດຕະຖານໄດ້ພະຍາຍາມຊ່ວຍ
ກັບການຮັກສາສິ່ງທີ່ nippy, ບໍ່ແມ່ນຢ່າງຫນ້ອຍເນື່ອງຈາກວ່າມັນພະຍາຍາມ ບໍ່ ສອບຖາມຖານຂໍ້ມູນຈົນກ່ວາ
ເວລາທີ່ເປັນໄປໄດ້ຫຼ້າສຸດ, ແຕ່ອ່ານເອກະສານທີ່ມາພ້ອມກັບຫ້ອງສະຫມຸດທີ່ທ່ານເລືອກ.
ໃນບັນດາບັນຫາຫຼາຍຢ່າງທີ່ຜູ້ພັດທະນາທີ່ຈັດການກັບຖານຂໍ້ມູນຄວນລະວັງແມ່ນ
ເພື່ອໃຊ້ຕົວຍຶດ "SQL" ສະເໝີ ແລະພິຈາລະນາຊຸດຂໍ້ມູນກ່ອນການດຶງຂໍ້ມູນເມື່ອອັນນີ້ອາດຈະ
ພິສູດໄດ້ປຽບ. ການແຍກໄຟລ໌ຂະໜາດໃຫຍ່ໂດຍການມອບໝາຍຂະບວນການຫຼາຍອັນເພື່ອວິເຄາະ
ໄຟລ໌ດຽວ, ການນໍາໃຊ້ເວົ້າວ່າ "POE", "ກະທູ້" ຫຼື "ສ້ອມ" ຍັງສາມາດເປັນວິທີທີ່ເປັນປະໂຫຍດຂອງການເພີ່ມປະສິດທິພາບ.
ການນໍາໃຊ້ຊັບພະຍາກອນ "CPU" ທີ່ມີຢູ່, ເຖິງແມ່ນວ່າເຕັກນິກນີ້ແມ່ນ fraught ກັບ
ບັນຫາທີ່ສອດຄ້ອງກັນແລະຮຽກຮ້ອງໃຫ້ມີຄວາມເອົາໃຈໃສ່ສູງໃນລະອຽດ.

ທຸກໆກໍລະນີມີຄໍາຮ້ອງສະຫມັກສະເພາະແລະຂໍ້ຍົກເວັ້ນຫນຶ່ງຫຼືຫຼາຍກວ່ານັ້ນ, ແລະບໍ່ມີ
ການທົດແທນການດໍາເນີນການທົດສອບຈໍານວນຫນ້ອຍຫນຶ່ງແລະຊອກຫາວິທີການເຮັດວຽກທີ່ດີທີ່ສຸດສໍາລັບທ່ານ
ສະພາບແວດລ້ອມໂດຍສະເພາະ, ນີ້ແມ່ນເຫດຜົນທີ່ວ່າການຂຽນລະຫັດທີ່ດີທີ່ສຸດບໍ່ແມ່ນວິທະຍາສາດທີ່ແນ່ນອນ, ແລະເປັນຫຍັງ
ພວກເຮົາມັກໃຊ້ Perl ຫຼາຍ - TMTOWTDI.

ມາດຕະຖານ

ນີ້ແມ່ນບາງຕົວຢ່າງເພື່ອສະແດງໃຫ້ເຫັນການນໍາໃຊ້ເຄື່ອງມືການປຽບທຽບຂອງ Perl.

ການມອບ ໝາຍ ແລະ ການອ້າງອິງ ຕົວແປ
ຂ້ອຍແນ່ໃຈວ່າພວກເຮົາສ່ວນໃຫຍ່ໄດ້ເຫັນລະຫັດທີ່ເບິ່ງຄືວ່າ, (ຫຼືຮ້າຍແຮງກວ່າ), ນີ້:

ຖ້າ ($obj->{_ref}->{_myscore} >= $obj->{_ref}->{_yourscore} ) {
...

ລະຫັດປະເພດນີ້ສາມາດເປັນການອ່ານແທ້ໆ, ເຊັ່ນດຽວກັນກັບຄວາມອ່ອນໄຫວຫຼາຍຕໍ່ການພິມຜິດ,
ແລະມັນຈະແຈ້ງກວ່າທີ່ຈະປະຕິເສດຕົວແປຢ່າງຈະແຈ້ງ. ພວກເຮົາກໍາລັງຂ້າງຄຽງ stepping ໄດ້
ບັນຫາຂອງການເຮັດວຽກກັບເຕັກນິກການຂຽນໂປລແກລມແບບວັດຖຸເພື່ອ encapsulate ຕົວແປ
ເຂົ້າເຖິງໂດຍຜ່ານວິທີການ, ເຂົ້າເຖິງໄດ້ໂດຍຜ່ານວັດຖຸ. ໃນທີ່ນີ້ພວກເຮົາພຽງແຕ່ປຶກສາຫາລື
ການປະຕິບັດດ້ານວິຊາການຂອງທາງເລືອກ, ແລະບໍ່ວ່າຈະເປັນນີ້ມີຜົນກະທົບປະສິດທິພາບ. ພວກເຮົາສາມາດ
ເບິ່ງວ່າການປະຕິບັດການອ້າງອິງນີ້, ມີຄ່າໃຊ້ຈ່າຍໃດໆໂດຍການໃສ່ລະຫັດປຽບທຽບ
ໄຟລ໌ແລະແລ່ນການທົດສອບ "Benchmark".

# ການອ້າງອີງ

#!/usr/bin/perl

ໃຊ້ຢ່າງເຄັ່ງຄັດ;
ການນໍາໃຊ້ຄໍາເຕືອນ;

ໃຊ້ Benchmark;

$ref ຂອງຂ້ອຍ = {
'ອ້າງອີງ' => {
_myscore => '100 + 1',
_youscore => '102 - 1' ,
},
};

ເວລາເຫຼົ່ານີ້(1000000, {
'ໂດຍກົງ' => ຍ່ອຍ {
$x ຂອງຂ້ອຍ = $ref->{ref}->{_myscore} . $ref->{ref}->{_youscore} ;
},
'ການອ້າງອີງ' => ຍ່ອຍ {
$ref ຂອງຂ້ອຍ = $ref->{ref};
$myscore ຂອງຂ້ອຍ = $ref->{_myscore};
$youscore ຂອງຂ້ອຍ = $ref->{_youscore};
$x ຂອງຂ້ອຍ = $myscore . $youscore;
},
});

ມັນເປັນສິ່ງຈໍາເປັນທີ່ຈະດໍາເນີນການວັດແທກໄລຍະເວລາໃດຫນຶ່ງຈໍານວນເວລາພຽງພໍເພື່ອໃຫ້ຕົວເລກ
ຕົກລົງເປັນຕົວເລກສະເລ່ຍ, ຖ້າບໍ່ດັ່ງນັ້ນແຕ່ລະໄລຍະຈະເຫນັງຕີງຕາມທໍາມະຊາດຍ້ອນ
ການປ່ຽນແປງສະພາບແວດລ້ອມ, ເພື່ອຫຼຸດຜ່ອນຜົນກະທົບຂອງການຂັດແຍ້ງສໍາລັບ "CPU" ຊັບພະຍາກອນແລະ
ຕົວຢ່າງແບນວິດເຄືອຂ່າຍ. ແລ່ນລະຫັດຂ້າງເທິງສໍາລັບຫນຶ່ງລ້ານ iterations, ພວກເຮົາສາມາດເຮັດໄດ້
ເບິ່ງຜົນໄດ້ຮັບຂອງບົດລາຍງານໂດຍໂມດູນ "Benchmark", ເພື່ອເບິ່ງວ່າວິທີການໃດແມ່ນ
ມີປະສິດທິພາບທີ່ສຸດ.

$> perl dereference

Benchmark: ກໍານົດເວລາ 1000000 iterations of dereference, direct...
dereference: 2 wallclock secs (1.59 usr + 0.00 sys = 1.59 CPU) @ 628930.82/s (n=1000000)
ໂດຍກົງ: 1 wallclock secs (1.20 usr + 0.00 sys = 1.20 CPU) @ 833333.33/s (n=1000000)

ຄວາມແຕກຕ່າງແມ່ນເຫັນໄດ້ຊັດເຈນແລະວິທີການ deferencing ແມ່ນຊ້າກວ່າ. ໃນຂະນະທີ່ມັນຄຸ້ມຄອງ
ເພື່ອປະຕິບັດໂດຍສະເລ່ຍຂອງ 628,930 ເທື່ອຕໍ່ວິນາທີໃນລະຫວ່າງການທົດສອບຂອງພວກເຮົາ, ວິທີການໂດຍກົງ
ແຕ່ຫນ້າເສຍດາຍ, ສາມາດດໍາເນີນການເພີ່ມເຕີມ 204,403 ເທື່ອ. ແຕ່ຫນ້າເສຍດາຍ, ຍ້ອນວ່າມີ
ມີຫຼາຍຕົວຢ່າງຂອງລະຫັດທີ່ຂຽນໂດຍໃຊ້ການເຂົ້າຫາຕົວແປໂດຍກົງຫຼາຍຊັ້ນ, ແລະ
ປົກກະຕິແລ້ວມັນເປັນຕາຢ້ານ. ຢ່າງໃດກໍຕາມ, ມັນແມ່ນຫນ້ອຍໄວ. ຄໍາຖາມຍັງຄົງຢູ່ບໍ່ວ່າ
ຕົວຈິງແລ້ວການໄດ້ຮັບນາທີແມ່ນຄຸ້ມຄ່າກັບສາຍຕາ, ຫຼືການສູນເສຍການຮັກສາ.

ຄົ້ນຫາ ແລະ ທົດແທນ or tr
ຖ້າພວກເຮົາມີສະຕຣິງທີ່ຕ້ອງໄດ້ຮັບການແກ້ໄຂ, ໃນຂະນະທີ່ regex ເກືອບສະເຫມີຈະມີຫຼາຍ
ມີຄວາມຍືດຫຍຸ່ນຫຼາຍ, "tr", ເຄື່ອງມືທີ່ຖືກນໍາໃຊ້ເລື້ອຍໆ, ຍັງສາມາດເປັນປະໂຫຍດ. ສະຖານະການຫນຶ່ງອາດຈະເປັນ
ແທນທີ່ vowels ທັງຫມົດດ້ວຍຕົວອັກສອນອື່ນ. ການແກ້ໄຂ regex ອາດຈະເບິ່ງຄືວ່ານີ້:

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

ທາງເລືອກ "tr" ອາດຈະເບິ່ງຄືວ່ານີ້:

$str =~ tr/aeiou//

ພວກເຮົາສາມາດເອົາມັນເຂົ້າໄປໃນໄຟລ໌ທົດສອບທີ່ພວກເຮົາສາມາດດໍາເນີນການເພື່ອກວດເບິ່ງວ່າວິທີການໃດໄວທີ່ສຸດ,
ການນໍາໃຊ້ຕົວແປ $STR ທົ່ວໂລກເພື່ອກໍາຫນົດໃຫ້ຕົວແປ "my $str" ເພື່ອຫຼີກເວັ້ນການ perl
ພະຍາຍາມປັບປຸງວຽກງານໃດນຶ່ງໃຫ້ເໝາະສົມໂດຍສັງເກດເຫັນວ່າມັນຖືກມອບໝາຍໃຫ້ພຽງຄັ້ງດຽວເທົ່ານັ້ນ.

# regex-ແປ

#!/usr/bin/perl

ໃຊ້ຢ່າງເຄັ່ງຄັດ;
ການນໍາໃຊ້ຄໍາເຕືອນ;

ໃຊ້ Benchmark;

$STR ຂອງຂ້ອຍ = "$$- this and that";

ເວລາເຫຼົ່ານີ້(1000000, {
'sr' => ຍ່ອຍ { ຂອງຂ້ອຍ $str = $STR; $str =~ s/[aeiou]/x/g; ກັບຄືນ $str; },
'tr' => ຍ່ອຍ {ຂອງຂ້ອຍ $str = $STR; $str =~ tr/aeiou//; ກັບຄືນ $str; },
});

ແລ່ນລະຫັດໃຫ້ຜົນໄດ້ຮັບຂອງພວກເຮົາ:

$> perl regex-transliterate

Benchmark: ກໍານົດເວລາ 1000000 iterations of sr, tr...
sr: 2 wallclock secs (1.19 usr + 0.00 sys = 1.19 CPU) @ 840336.13/s (n=1000000)
tr: 0 wallclock secs (0.49 usr + 0.00 sys = 0.49 CPU) @ 2040816.33/s (n=1000000)

ສະບັບ "tr" ແມ່ນຜູ້ຊະນະທີ່ຊັດເຈນ. ການແກ້ໄຂຫນຶ່ງແມ່ນມີຄວາມຍືດຫຍຸ່ນ, ອີກອັນຫນຶ່ງແມ່ນໄວ - ແລະ
ມັນເປັນການເລືອກທີ່ເຫມາະສົມຂອງໂຄງການທີ່ຈະນໍາໃຊ້.

ກວດເບິ່ງເອກະສານ "Benchmark" ສໍາລັບເຕັກນິກທີ່ເປັນປະໂຫຍດຕື່ມອີກ.

ການປະກອບຂໍ້ມູນ ເຄື່ອງມື

ລະຫັດຂະຫນາດໃຫຍ່ເລັກນ້ອຍຈະສະຫນອງບາງສິ່ງບາງຢ່າງທີ່ profiler ສາມາດຜະລິດໄດ້
ສະຖິຕິການລາຍງານທີ່ກວ້າງຂວາງກວ່າ. ຕົວຢ່າງນີ້ໃຊ້ໂຄງການ "wordmatch" ທີ່ງ່າຍດາຍ
ເຊິ່ງ parses ໄຟລ໌ປ້ອນຂໍ້ມູນໃຫ້ແລະ spews ອອກບົດລາຍງານສັ້ນກ່ຽວກັບເນື້ອໃນ.

# ຄຳສັບ

#!/usr/bin/perl

ໃຊ້ຢ່າງເຄັ່ງຄັດ;
ການນໍາໃຊ້ຄໍາເຕືອນ;

=head1 NAME

filewords - ການວິເຄາະຄໍາສັບຂອງໄຟລ໌ປ້ອນຂໍ້ມູນ

=head1 ສະຫຼຸບສັງລວມ

filewords -f inputfilename [-d]

=head1 ລາຍລະອຽດ

ໂຄງການນີ້ອະນຸຍາດຊື່ໄຟລ໌ທີ່ໄດ້ຮັບ, ລະບຸໄວ້ດ້ວຍ C<-f>, ແລະສະແດງ a
ການວິເຄາະງ່າຍດາຍຂອງຄໍາສັບຕ່າງໆທີ່ພົບເຫັນຢູ່ໃນນັ້ນ. ໃຊ້ປຸ່ມ C<-d> ເພື່ອເປີດໃຊ້ງານ
ແກ້ບັນຫາຂໍ້ຄວາມ.

= ຕັດ

ໃຊ້ FileHandle;
ໃຊ້ Getopt::Long;

$debug ຂອງຂ້ອຍ = 0;
$file ຂອງຂ້ອຍ = '';

$result ຂອງຂ້ອຍ = GetOptions (
'ດີບັກ' => \$debug,
'file=s' => \$file,
);
die("args ບໍ່ຖືກຕ້ອງ") ເວັ້ນເສຍແຕ່ $result;

ເວັ້ນເສຍແຕ່ ( -f $file ) {
die("Usage: $0 -f filename [-d]");
}
ຂອງຂ້ອຍ $FH = FileHandle->new("< $file") ຫຼື die("ບໍ່ສາມາດເປີດໄຟລ໌($file): $!");

$i_LINES ຂອງຂ້ອຍ = 0;
$i_WORDS ຂອງຂ້ອຍ = 0;
%count = ();

@lines ຂອງຂ້ອຍ = <$FH>;
foreach my $line (@lines ) {
$i_LINES++;
$line =~ s/\n//;
my @words = ແຍກ(/ +/, $line);
$i_words ຂອງຂ້ອຍ = scalar(@words);
$i_WORDS = $i_WORDS + $i_words;
debug("line: $i_LINES ສະໜອງ $i_words words: @words");
$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_wd ຂອງຂ້ອຍ = shift;
my $word = shift;
$regex ຂອງຂ້ອຍ = shift;
ຂອງຂ້ອຍ $ has = 0;

ຖ້າ ($word =~ /($regex)/ ) {
$ has++ ຖ້າ $1;
}

debug("ຄຳສັບ: $i_wd ".($has ? 'match' : 'ບໍ່ກົງກັນ')." chars: /$regex/");

ກັບຄືນ $ has;
}

ບົດລາຍງານຍ່ອຍ {
ລາຍງານ % ຂອງຂ້ອຍ = @_;
%rep ຂອງຂ້ອຍ;

foreach my $line (ກະແຈ %report ) {
foreach $key ຂອງຂ້ອຍ (ກະແຈ %{ $report{$line} } ) {
$rep{$key} += $report{$line}{$key};
}
}

$ ລາຍງານຂອງຂ້ອຍ = qq|
ລາຍງານ $0 ສໍາລັບ $file:
ແຖວໃນໄຟລ໌: $i_LINES
ຄໍາທີ່ຢູ່ໃນໄຟລ໌: $i_WORDS
ຄໍາທີ່ມີຕົວອັກສອນພິເສດ (ບໍ່ແມ່ນຄໍາ): $i_spec
ຄໍາທີ່ມີພຽງແຕ່ຕົວອັກສອນພິເສດ (ບໍ່ແມ່ນຄໍາ): $i_only
ຄຳສັບທີ່ມີພຽງແຕ່ພະຍັນຊະນະ: $i_cons
ຄໍາທີ່ມີພຽງແຕ່ຕົວພິມໃຫຍ່: $i_caps
ຄໍາທີ່ມີພຽງແຕ່ vowels: $i_vows
|;

ກັບຄືນ $report;
}

ແກ້ບັນຫາຍ່ອຍ {
my $message = shift;

ຖ້າ ( $debug ) {
ພິມ STDERR "DBG: $message\n";
}
}

ອອກຈາກ 0;

ພັດທະນາ::DProf
ໂມດູນທີ່ເຄົາລົບນີ້ເປັນມາດຕະຖານ de-facto ສໍາລັບການສ້າງລະຫັດ Perl ສໍາລັບຫຼາຍກ່ວາ
ທົດສະວັດ, ແຕ່ໄດ້ຖືກປ່ຽນແທນດ້ວຍໂມດູນອື່ນໆຈໍານວນຫນຶ່ງທີ່ໄດ້ນໍາພວກເຮົາກັບຄືນໄປບ່ອນ
ສະຕະວັດທີ 21. ເຖິງແມ່ນວ່າທ່ານແນະນໍາໃຫ້ປະເມີນເຄື່ອງມືຂອງທ່ານຈາກຫຼາຍໆຢ່າງ
ທີ່ໄດ້ກ່າວມາໃນທີ່ນີ້ແລະຈາກບັນຊີລາຍຊື່ CPAN ຢູ່ໃນພື້ນຖານຂອງເອກະສານນີ້, (ແລະປະຈຸບັນ
Devel::NYTProf ເບິ່ງຄືວ່າເປັນອາວຸດຂອງທາງເລືອກ - ເບິ່ງຂ້າງລຸ່ມນີ້), ພວກເຮົາຈະພິຈາລະນາຢ່າງໄວວາ
ຜົນໄດ້ຮັບຈາກ Devel::DPF ທໍາອິດ, ເພື່ອກໍານົດພື້ນຖານສໍາລັບເຄື່ອງມື Perl profile. ດໍາເນີນການ
ໂຄງການຂ້າງເທິງພາຍໃຕ້ການຄວບຄຸມຂອງ "Devel::DPF" ໂດຍໃຊ້ປຸ່ມ "-d" ໃນຄໍາສັ່ງ
ເສັ້ນ.

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

<...ຫຼາຍເສັ້ນຖືກຕັດອອກ...>

ບົດລາຍງານ wordmatch ສໍາລັບ perl5db.pl:
ເສັ້ນໃນເອກະສານ: 9428
ຄໍາສັບຕ່າງໆໃນໄຟລ໌: 50243
ຄໍາສັບຕ່າງໆທີ່ມີຕົວອັກສອນພິເສດ (ບໍ່ແມ່ນຄໍາ): 20480
ຄໍາທີ່ມີພຽງແຕ່ຕົວອັກສອນພິເສດ (ບໍ່ແມ່ນຄໍາ): 7790
ຄຳສັບທີ່ມີພຽງແຕ່ພະຍັນຊະນະ: 4801
ຄໍາທີ່ມີພຽງແຕ່ຕົວພິມໃຫຍ່: 1316
ຄໍາສັບຕ່າງໆທີ່ມີພຽງແຕ່ vowels: 1701

"Devel::DPF" ຜະລິດໄຟລ໌ພິເສດ, ເອີ້ນວ່າ tmon.out ໂດຍຄ່າເລີ່ມຕົ້ນ, ແລະໄຟລ໌ນີ້ຖືກອ່ານ
ໂດຍໂຄງການ "dprofpp", ເຊິ່ງໄດ້ຖືກຕິດຕັ້ງແລ້ວເປັນສ່ວນຫນຶ່ງຂອງ "Devel::DPF"
ການແຜ່ກະຈາຍ. ຖ້າທ່ານໂທຫາ "dprofpp" ໂດຍບໍ່ມີທາງເລືອກ, ມັນຈະອ່ານຂໍ້ຄວາມ tmon.out ຍື່ນໃນ
ໄດເລກະທໍລີໃນປະຈຸບັນແລະຜະລິດບົດລາຍງານສະຖິຕິທີ່ສາມາດອ່ານໄດ້ຂອງມະນຸດຂອງການດໍາເນີນງານຂອງທ່ານ
ໂຄງການ. ໃຫ້ສັງເກດວ່ານີ້ອາດຈະໃຊ້ເວລາເລັກນ້ອຍ.

$> dprofpp

ເວລາຜ່ານໄປທັງໝົດ = 2.951677 ວິນາທີ
ເວລາຜູ້ໃຊ້+ລະບົບ = 2.871677 ວິນາທີ
ເວລາພິເສດ
%Time ExclSec CumulS #Calls sec/call Csec/c ຊື່
102. 2.945 3.003 251215 0.0000 0.0000 ຫຼັກ:: matches
2.40 0.069 0.069 260643 0.0000 0.0000 ຫຼັກ::debug
1.74 0.050 0.050 1 0.0500 0.0500 ຫຼັກ:: ລາຍງານ
1.04 0.030 0.049 4 0.0075 0.0123 ຫຼັກ::BEGIN
0.35 0.010 0.010 3 0.0033 0.0033 ຜູ້ສົ່ງອອກ::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 - - ສັນຍາລັກ::BEGIN
0.00 - -0.000 1 - - Fcntl::BEGIN
0.00 - -0.000 1 - - Fcntl::bootstrap
0.00 - -0.000 1 - - ການເຕືອນໄພ::BEGIN
0.00 - -0.000 1 - - IO::bootstrap
0.00 - -0.000 1 - - Getopt::Long::ConfigDefaults
0.00 - -0.000 1 - - Getopt::Long::Configure
0.00 - -0.000 1 - - ສັນຍາລັກ::gensym

"dprofpp" ຈະຜະລິດບົດລາຍງານທີ່ຂ້ອນຂ້າງລະອຽດກ່ຽວກັບກິດຈະກໍາຂອງ "wordmatch"
ໂຄງການ. ໂມງປຸກ, ຜູ້ໃຊ້ແລະລະບົບ, ເວລາແມ່ນຢູ່ເທິງສຸດຂອງການວິເຄາະ, ແລະຫຼັງຈາກ
ນີ້ແມ່ນຄໍລໍາຕົ້ນຕໍທີ່ກໍານົດການກໍານົດບົດລາຍງານ. ກວດເບິ່ງເອກະສານ "dprofpp" ສໍາລັບ
ລາຍລະອຽດຂອງຫຼາຍທາງເລືອກທີ່ມັນສະຫນັບສະຫນູນ.

ເບິ່ງ "Apache::DPF" ທີ່ເຊື່ອມຕໍ່ "Devel::DPF" ເຂົ້າໄປໃນ "mod_perl".

ພັດທະນາ::Profileer
ລອງມາເບິ່ງໂປຣແກຣມດຽວກັນໂດຍໃຊ້ໂປໄຟເຊີທີ່ແຕກຕ່າງກັນ: "Devel::Profiler", a
ການຫຼຸດລົງໃນການທົດແທນ Perl ເທົ່ານັ້ນສໍາລັບ "Devel::DPF". ການນໍາໃຊ້ແມ່ນແຕກຕ່າງກັນເລັກນ້ອຍໃນ
ວ່າແທນທີ່ຈະໃຊ້ທຸງ "-d:" ພິເສດ, ທ່ານດຶງ "Devel::Profiler" ໂດຍກົງເປັນ.
ໂມດູນໂດຍໃຊ້ "-M".

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

<...ຫຼາຍເສັ້ນຖືກຕັດອອກ...>

ບົດລາຍງານ wordmatch ສໍາລັບ perl5db.pl:
ເສັ້ນໃນເອກະສານ: 9428
ຄໍາສັບຕ່າງໆໃນໄຟລ໌: 50243
ຄໍາສັບຕ່າງໆທີ່ມີຕົວອັກສອນພິເສດ (ບໍ່ແມ່ນຄໍາ): 20480
ຄໍາທີ່ມີພຽງແຕ່ຕົວອັກສອນພິເສດ (ບໍ່ແມ່ນຄໍາ): 7790
ຄຳສັບທີ່ມີພຽງແຕ່ພະຍັນຊະນະ: 4801
ຄໍາທີ່ມີພຽງແຕ່ຕົວພິມໃຫຍ່: 1316
ຄໍາສັບຕ່າງໆທີ່ມີພຽງແຕ່ vowels: 1701

"Devel::Profiler" ສ້າງໄຟລ໌ tmon.out ເຊິ່ງເຂົ້າກັນໄດ້ກັບ "dprofpp"
ໂຄງການ, ດັ່ງນັ້ນການປະຢັດການກໍ່ສ້າງຂອງໂຄງການສະຖິຕິການອ່ານທີ່ອຸທິດຕົນ. "dprofpp"
ດັ່ງນັ້ນການນໍາໃຊ້ແມ່ນຄືກັນກັບຕົວຢ່າງຂ້າງເທິງ.

$> dprofpp

ເວລາຜ່ານໄປທັງໝົດ = 20.984 ວິນາທີ
ເວລາຜູ້ໃຊ້+ລະບົບ = 19.981 ວິນາທີ
ເວລາພິເສດ
%Time ExclSec CumulS #Calls sec/call Csec/c ຊື່
49.0 9.792 14.509 251215 0.0000 0.0001 ຫຼັກ:: matches
24.4 4.887 4.887 260643 0.0000 0.0000 ຫຼັກ::debug
0.25 0.049 0.049 1 0.0490 0.0490 ຫຼັກ:: ລາຍງານ
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::new
0.00 0.000 0.000 1 0.0000 0.0000 IO::Handle::new
0.00 0.000 0.000 1 0.0000 0.0000 ສັນຍາລັກ::gensym
0.00 0.000 0.000 1 0.0000 0.0000 IO::File::open

ຫນ້າສົນໃຈພວກເຮົາໄດ້ຮັບຜົນໄດ້ຮັບທີ່ແຕກຕ່າງກັນເລັກນ້ອຍ, ເຊິ່ງສ່ວນໃຫຍ່ແມ່ນຍ້ອນສູດການຄິດໄລ່
ທີ່ສ້າງບົດລາຍງານແມ່ນແຕກຕ່າງກັນ, ເຖິງແມ່ນວ່າຮູບແບບເອກະສານຜົນຜະລິດໄດ້ຖືກກ່າວຫາ
ຄືກັນ. ເວລາທີ່ຜ່ານໄປ, ຜູ້ໃຊ້ແລະລະບົບແມ່ນສະແດງໃຫ້ເຫັນຢ່າງຊັດເຈນເຖິງເວລາທີ່ມັນໃຊ້ເວລາ
"Devel::Profiler" ເພື່ອປະຕິບັດການແລ່ນຂອງມັນເອງ, ແຕ່ລາຍຊື່ຖັນຮູ້ສຶກວ່າຖືກຕ້ອງກວ່າ
somehow ກ່ວາສິ່ງທີ່ພວກເຮົາມີກ່ອນຫນ້ານີ້ຈາກ "Devel::DPF". ຕົວເລກ 102% ມີ
ຫາຍໄປ, ສໍາລັບການຍົກຕົວຢ່າງ. ນີ້ແມ່ນບ່ອນທີ່ພວກເຮົາຕ້ອງໃຊ້ເຄື່ອງມືໃນການກໍາຈັດຂອງພວກເຮົາ, ແລະ
ຮັບຮູ້ຂໍ້ດີແລະຂໍ້ເສຍຂອງເຂົາເຈົ້າ, ກ່ອນທີ່ຈະນໍາໃຊ້ພວກມັນ. ຫນ້າສົນໃຈ, ຈໍານວນການໂທສໍາລັບ
ແຕ່ລະ subroutine ແມ່ນຄືກັນໃນສອງບົດລາຍງານ, ມັນແມ່ນອັດຕາສ່ວນທີ່ແຕກຕ່າງກັນ. ເປັນ
ຜູ້ຂຽນຂອງ "Devel::Proviler" ຂຽນວ່າ:

...ແລ່ນ HTML::ຊຸດທົດສອບຂອງແມ່ແບບພາຍໃຕ້ Devel::DProf ສະແດງຜົນຜະລິດ()
ບໍ່ໃຊ້ເວລາແຕ່ Devel::Profiler ສະແດງໃຫ້ເຫັນປະມານ 10% ຂອງເວລາແມ່ນຢູ່ໃນຜົນຜະລິດ().
ຂ້ອຍບໍ່ຮູ້ວ່າຈະເຊື່ອອັນໃດ ແຕ່ ລຳ ໄສ້ຂອງຂ້ອຍບອກຂ້ອຍວ່າມີບາງຢ່າງຜິດພາດ
ພັດທະນາ::DProf. HTML::Template::output() ເປັນການປົກກະຕິອັນໃຫຍ່ທີ່ຮຽກຮ້ອງ
ທຸກໆການທົດສອບ. ໃນກໍລະນີໃດກໍ່ຕາມ, ບາງສິ່ງບາງຢ່າງຕ້ອງການແກ້ໄຂ.

YMMV.

ເບິ່ງ "Devel::Apache::Profiler" ເຊິ່ງເຊື່ອມຕໍ່ "Devel::Profiler" ເຂົ້າໄປໃນ "mod_perl".

ພັດທະນາ::SmallProf
ໂປໄຟເຊີ "Devel::SmallProf" ກວດເບິ່ງເວລາແລ່ນຂອງໂຄງການ Perl ຂອງທ່ານແລະຜະລິດ
ລາຍຊື່ແຖວຕໍ່ແຖວເພື່ອສະແດງວ່າແຕ່ລະແຖວຖືກເອີ້ນຈັກເທື່ອ, ແລະແຕ່ລະສາຍຍາວເທົ່າໃດ
ໄດ້ຮັບການປະຕິບັດ. ມັນຖືກເອີ້ນວ່າໂດຍການສະຫນອງທຸງ "-d" ທີ່ຄຸ້ນເຄີຍກັບ Perl ໃນເວລາແລ່ນ.

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

<...ຫຼາຍເສັ້ນຖືກຕັດອອກ...>

ບົດລາຍງານ wordmatch ສໍາລັບ perl5db.pl:
ເສັ້ນໃນເອກະສານ: 9428
ຄໍາສັບຕ່າງໆໃນໄຟລ໌: 50243
ຄໍາສັບຕ່າງໆທີ່ມີຕົວອັກສອນພິເສດ (ບໍ່ແມ່ນຄໍາ): 20480
ຄໍາທີ່ມີພຽງແຕ່ຕົວອັກສອນພິເສດ (ບໍ່ແມ່ນຄໍາ): 7790
ຄຳສັບທີ່ມີພຽງແຕ່ພະຍັນຊະນະ: 4801
ຄໍາທີ່ມີພຽງແຕ່ຕົວພິມໃຫຍ່: 1316
ຄໍາສັບຕ່າງໆທີ່ມີພຽງແຕ່ vowels: 1701

"Devel::SmallProf" ຂຽນມັນອອກເປັນໄຟລ໌ທີ່ເອີ້ນວ່າ smallprof.out, ໂດຍຄ່າເລີ່ມຕົ້ນ. ໄດ້
ຮູບແບບຂອງໄຟລ໌ເບິ່ງຄືນີ້:

:

ເມື່ອໂຄງການໄດ້ຢຸດເຊົາ, ຜົນຜະລິດອາດຈະຖືກກວດສອບແລະຈັດຮຽງໂດຍໃຊ້ມາດຕະຖານໃດກໍ່ຕາມ
ຜົນປະໂຫຍດການກັ່ນຕອງຂໍ້ຄວາມ. ບາງສິ່ງບາງຢ່າງເຊັ່ນ: ຕໍ່ໄປນີ້ອາດຈະພຽງພໍ:

$> cat smallprof.out | grep \d*: | ຄັດ -k3 | tac | ຫົວ -n20

251215 1.65674 7.68000 75: ຖ້າ ($word =~ /($regex)/ ) {
251215 0.03264 4.40000 79: debug("word: $i_wd ".($has ? 'match' :
251215 0.02693 4.10000 81: return $has;
260643 0.02841 4.07000 128: ຖ້າ ( $debug ) {
260643 0.02601 4.04000 126: my $message = shift;
251215 0.02641 3.91000 73: my $has = 0;
251215 0.03311 3.71000 70: ຂອງຂ້ອຍ $i_wd = shift;
251215 0.02699 3.69000 72: $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: $i_cons ຂອງຂ້ອຍ = matches($i_word, $word,
50243 0.48837 0.88000 63: $count{$i_LINES}{caps} =
50243 0.00516 0.88000 58: $i_caps ຂອງຂ້ອຍ = matches($i_word, $word, '^[(A-
50243 0.00631 0.81000 54: $i_spec ຂອງຂ້ອຍ = matches($i_word, $word, '[^a-
50243 0.00496 0.80000 57: $i_vows ຂອງຂ້ອຍ = matches($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: $i_only ຂອງຂ້ອຍ = matches($i_word, $word, '^[^a-
ທັນທີທັນໃດທ່ານສາມາດເບິ່ງຈຸດສຸມທີ່ແຕກຕ່າງກັນເລັກນ້ອຍກັບໂມດູນໂປຣໄຟລ໌ຍ່ອຍ,
ແລະພວກເຮົາເລີ່ມເບິ່ງວ່າເສັ້ນລະຫັດໃດໃຊ້ເວລາຫຼາຍທີ່ສຸດ. ເສັ້ນ regex ນັ້ນ
ເບິ່ງຄືວ່າມີຄວາມສົງໃສເລັກນ້ອຍ, ຕົວຢ່າງ. ຈື່ໄວ້ວ່າເຄື່ອງມືເຫຼົ່ານີ້ຄວນຈະເປັນ
ໃຊ້ຮ່ວມກັນ, ບໍ່ມີວິທີທີ່ດີທີ່ສຸດດຽວທີ່ຈະ profile ລະຫັດຂອງທ່ານ, ທ່ານຈໍາເປັນຕ້ອງໃຊ້ທີ່ດີທີ່ສຸດ
ເຄື່ອງມືສໍາລັບການເຮັດວຽກ.

ເບິ່ງ "Apache::SmallProf" ເຊິ່ງເຊື່ອມຕໍ່ "Devel::SmallProf" ເຂົ້າໄປໃນ "mod_perl".

ພັດທະນາ::FastProf
"Devel::FastProf" ແມ່ນຜູ້ສ້າງສາຍ Perl ອື່ນ. ນີ້ໄດ້ຖືກຂຽນດ້ວຍທັດສະນະທີ່ຈະໄດ້ຮັບ
ເປັນ profiler ເສັ້ນໄວ, ກ່ວາທີ່ເປັນໄປໄດ້ກັບຕົວຢ່າງ "Devel::SmallProf", ເນື່ອງຈາກວ່າມັນ
ຂຽນໃນ "C". ເພື່ອໃຊ້ "Devel::FastProf", ສະໜອງ "-d" argument ໃຫ້ກັບ Perl:

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

<...ຫຼາຍເສັ້ນຖືກຕັດອອກ...>

ບົດລາຍງານ wordmatch ສໍາລັບ perl5db.pl:
ເສັ້ນໃນເອກະສານ: 9428
ຄໍາສັບຕ່າງໆໃນໄຟລ໌: 50243
ຄໍາສັບຕ່າງໆທີ່ມີຕົວອັກສອນພິເສດ (ບໍ່ແມ່ນຄໍາ): 20480
ຄໍາທີ່ມີພຽງແຕ່ຕົວອັກສອນພິເສດ (ບໍ່ແມ່ນຄໍາ): 7790
ຄຳສັບທີ່ມີພຽງແຕ່ພະຍັນຊະນະ: 4801
ຄໍາທີ່ມີພຽງແຕ່ຕົວພິມໃຫຍ່: 1316
ຄໍາສັບຕ່າງໆທີ່ມີພຽງແຕ່ vowels: 1701

"Devel::FastProf" ຂຽນສະຖິຕິໃສ່ໄຟລ໌ fastprof.out ໃນລະບົບປະຈຸບັນ.
ໄຟລ໌ຜົນຜະລິດ, ທີ່ສາມາດກໍານົດໄດ້, ສາມາດຕີຄວາມຫມາຍໂດຍການນໍາໃຊ້ "fprofpp"
ໂປຣແກຣມເສັ້ນຄໍາສັ່ງ.

$> fprofpp | ຫົວ -n20

# ຮູບແບບຜົນຜະລິດ fprofpp ແມ່ນ:
# ຊື່ໄຟລ໌: ນັບເວລາສາຍ: ແຫຼ່ງ
wordmatch:75 3.93338 251215: ຖ້າ ($word =~ /($regex)/ ) {
wordmatch:79 1.77774 251215: debug("word: $i_wd ".($has ? 'match' : 'does not match')." chars: /$regex/");
wordmatch:81 1.47604 251215: return $has;
wordmatch:126 1.43441 260643: my $message = shift;
wordmatch:128 1.42156 260643: ຖ້າ ( $debug ) {
wordmatch:70 1.36824 251215: ຂອງຂ້ອຍ $i_wd = shift;
wordmatch:71 1.36739 251215: my $word = shift;
wordmatch:72 1.35939 251215: $regex ຂອງຂ້ອຍ = shift;

ທັນທີທີ່ພວກເຮົາສາມາດເຫັນໄດ້ວ່າຈໍານວນເວລາທີ່ແຕ່ລະສາຍໄດ້ຖືກເອີ້ນແມ່ນຄືກັນ
ຜົນຜະລິດ "Devel::SmallProf", ແລະລໍາດັບແມ່ນແຕກຕ່າງກັນເລັກນ້ອຍໂດຍອີງໃສ່
ການຈັດລໍາດັບຂອງຈໍານວນທີ່ໃຊ້ເວລາແຕ່ລະເສັ້ນທີ່ຈະປະຕິບັດ, "ຖ້າຫາກວ່າ ( $debug ) { " ແລະ "ຂອງຂ້ອຍ
$message = shift;", ສໍາລັບຕົວຢ່າງ. ຄວາມແຕກຕ່າງຂອງເວລາທີ່ແທ້ຈິງທີ່ບັນທຶກໄວ້ອາດຈະຢູ່ໃນ
algorithm ທີ່ໃຊ້ພາຍໃນ, ຫຼືມັນອາດຈະເປັນຍ້ອນການຈໍາກັດຊັບພະຍາກອນຂອງລະບົບຫຼື
ການຂັດແຍ້ງ.

ເບິ່ງ DBIx::Profile ເຊິ່ງຈະເຮັດໃຫ້ການສອບຖາມຖານຂໍ້ມູນທີ່ເຮັດວຽກພາຍໃຕ້ "DBIx::*"
namespace.

ພັດທະນາ::NYTProf
"Devel::NYTProf" ແມ່ນ ຕໍ່ໄປ ການຜະລິດ ຂອງ Perl code profiler, ການແກ້ໄຂຂໍ້ບົກຜ່ອງຈໍານວນຫຼາຍໃນ
ເຄື່ອງມືອື່ນໆແລະປະຕິບັດລັກສະນະເຢັນຈໍານວນຫຼາຍ. ກ່ອນອື່ນ ໝົດ, ມັນສາມາດຖືກ ນຳ ໃຊ້ເປັນ
ອອນໄລນ໌ profiler, ກ block ຫຼື ລະບົບຍ່ອຍ profiler, ທັງຫມົດໃນເວລາດຽວກັນ. ມັນຍັງສາມາດນໍາໃຊ້ sub-
ຄວາມລະອຽດ microsecond (100ns) ໃນລະບົບທີ່ໃຫ້ "clock_gettime()". ມັນສາມາດເປັນ
ເລີ່ມຕົ້ນແລະຢຸດເຊົາເຖິງແມ່ນວ່າໂຄງການທີ່ໄດ້ຮັບການ profiled. ມັນເປັນການເຂົ້າແຖວໜຶ່ງໄປຫາໂປຣໄຟລ໌
ຄໍາຮ້ອງສະຫມັກ "mod_perl". ມັນຂຽນເປັນ "c" ແລະອາດຈະເປັນໂປໄຟທີ່ໄວທີ່ສຸດ
ມີສໍາລັບ Perl. ບັນຊີລາຍຊື່ຂອງຄວາມເຢັນພຽງແຕ່ໄປສຸດ. ພຽງພໍແລ້ວ, ໃຫ້ເບິ່ງວິທີການ
ມັນເຮັດວຽກ - ພຽງແຕ່ໃຊ້ປຸ່ມ "-d" ທີ່ຄຸ້ນເຄີຍເພື່ອສຽບມັນແລະແລ່ນລະຫັດ.

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

ບົດລາຍງານ wordmatch ສໍາລັບ perl5db.pl:
ເສັ້ນໃນເອກະສານ: 9427
ຄໍາສັບຕ່າງໆໃນໄຟລ໌: 50243
ຄໍາສັບຕ່າງໆທີ່ມີຕົວອັກສອນພິເສດ (ບໍ່ແມ່ນຄໍາ): 20480
ຄໍາທີ່ມີພຽງແຕ່ຕົວອັກສອນພິເສດ (ບໍ່ແມ່ນຄໍາ): 7790
ຄຳສັບທີ່ມີພຽງແຕ່ພະຍັນຊະນະ: 4801
ຄໍາທີ່ມີພຽງແຕ່ຕົວພິມໃຫຍ່: 1316
ຄໍາສັບຕ່າງໆທີ່ມີພຽງແຕ່ vowels: 1701

"NYTProf" ຈະສ້າງຖານຂໍ້ມູນບົດລາຍງານເຂົ້າໄປໃນໄຟລ໌ nytprof.out ໂດຍຄ່າເລີ່ມຕົ້ນ. ມະນຸດ
ບົດລາຍງານທີ່ສາມາດອ່ານໄດ້ສາມາດຖືກສ້າງຕັ້ງຂຶ້ນຈາກທີ່ນີ້ໂດຍການນໍາໃຊ້ "nytprofhtml" ທີ່ສະຫນອງໃຫ້ (HTML
output) ແລະໂຄງການ "nytprofcsv" (CSV output). ພວກເຮົາໄດ້ໃຊ້ລະບົບ Unix "html2text"
ຜົນປະໂຫຍດໃນການແປງ nytprof/index.html ໄຟລ໌ເພື່ອຄວາມສະດວກຢູ່ທີ່ນີ້.

$> html2text nytprof/index.html

ດັດຊະນີໂປຣໄຟລ໌ປະສິດທິພາບ
ສໍາລັບ wordmatch
ດໍາເນີນການໃນວັນສຸກ 26 ກັນຍາ 13:46:39 2008
ລາຍງານວັນສຸກ ວັນທີ 26 ກັນຍາ 13:47:23 2008

15 ກິດຈະກຳຍ່ອຍອັນດັບຕົ້ນ - ຈັດຮຽງຕາມເວລາສະເພາະ
|ໂທ|P|F|ລວມ|ສະເພາະ|ລາຍການຍ່ອຍ|
| | | |ເວລາ |ເວລາ | |
|251215|5 |1 |13.09263 |10.47692 |ຫຼັກ:: |ການແຂ່ງຂັນ |
|260642|2 |1 |2.71199 |2.71199 |ຕົ້ນຕໍ:: |debug |
|1 |1 |1 |0.21404 |0.21404 |ຕົ້ນຕໍ:: |ບົດລາຍງານ |
|2 |2 |2 |0.00511 |0.00511 |XSLoader:: |load (xsub) |
|14 |14|7 |0.00304 |0.00298 |ຜູ້ສົ່ງອອກ:: |ນໍາເຂົ້າ |
|3 |1 |1 |0.00265 |0.00254 |ຜູ້ສົ່ງອອກ:: |as_heavy |
|10 |10|4 |0.00140 |0.00140 |vars:: |ນຳເຂົ້າ |
|13 |13|1 |0.00129 |0.00109 |ຄົງທີ່:: |ນໍາເຂົ້າ |
|1 |1 |1 |0.00360 |0.00096 |FileHandle:: |ນໍາເຂົ້າ |
|3 |3 |3 |0.00086 |0.00074 |ຄຳເຕືອນ::ລົງທະບຽນ::|ນຳເຂົ້າ |
|9 |3 |1 |0.00036 |0.00036 |ເຂັ້ມງວດ:: |ບິດ |
|13 |13|13|0.00032 |0.00029 |ເຂັ້ມງວດ:: |ນໍາເຂົ້າ |
|2 |2 |2 |0.00020 |0.00020 |ຄຳເຕືອນ:: |ນຳເຂົ້າ |
|2 |1 |1 |0.00020 |0.00020 |Getopt::Long:: |ParseOptionSpec|
|7 |7 |6 |0.00043 |0.00020 |ເຂັ້ມງວດ:: |unimport |

ສໍາລັບຂໍ້ມູນເພີ່ມເຕີມເບິ່ງບັນຊີລາຍຊື່ເຕັມຂອງ 189 subroutines.

ສ່ວນທໍາອິດຂອງບົດລາຍງານແລ້ວສະແດງໃຫ້ເຫັນຂໍ້ມູນທີ່ສໍາຄັນກ່ຽວກັບອັນໃດ
subroutines ແມ່ນໃຊ້ເວລາຫຼາຍທີ່ສຸດ. ຕໍ່ໄປໃຫ້ສະຖິຕິບາງຢ່າງກ່ຽວກັບແຫຼ່ງ
ໄຟລ໌ profiled.

ໄຟລ໌ລະຫັດແຫຼ່ງ - ສັ່ງໂດຍເວລາພິເສດຫຼັງຈາກນັ້ນຊື່
|Stmts|ສະເພາະ|ສະເລ່ຍ. |ບົດລາຍງານ|ແຫຼ່ງທີ່ມາ|
| |ເວລາ | | | |
|2699761|15.66654 |6e-06 |line . ຕັນ. sub|wordmatch|
|35 |0.02187 |0.00062|ເສັ້ນ . ຕັນ. sub|IO/Handle.pm |
|274 |0.01525 |0.00006|ເສັ້ນ . ຕັນ. sub|Getopt/Long.pm |
|20 |0.00585 |0.00029|ເສັ້ນ . ຕັນ. ຍ່ອຍ|Fcntl.pm|
|128 |0.00340 |0.00003|ເສັ້ນ . ຕັນ. sub|Exporter/Heavy.pm |
|42 |0.00332 |0.00008|ເສັ້ນ . ຕັນ. sub|IO/File.pm |
|261 |0.00308 |0.00001|ແຖວ . ຕັນ. sub|ຜູ້ສົ່ງອອກ.pm|
|323 |0.00248 |8e-06 |line . ຕັນ. sub|constant.pm|
|12 |0.00246 |0.00021|ແຖວ . ຕັນ. sub|File/Spec/Unix.pm |
|191 |0.00240 |0.00001|ແຖວ . ຕັນ. sub|vars.pm|
|77 |0.00201 |0.00003|ເສັ້ນ . ຕັນ. sub|FileHandle.pm|
|12 |0.00198 |0.00016|ແຖວ . ຕັນ. ຍ່ອຍ|Carp.pm|
|14 |0.00175 |0.00013|ແຖວ . ຕັນ. sub|Symbol.pm|
|15 |0.00130 |0.00009|ເສັ້ນ . ຕັນ. sub|IO.pm|
|22 |0.00120 |0.00005|ແຖວ . ຕັນ. sub|IO/Seekable.pm |
|198 |0.00085 |4e-06 |line . ຕັນ. sub|warnings/register.pm|
|114 |0.00080 |7e-06 |line . ຕັນ. sub|strict.pm|
|47 |0.00068 |0.00001|ແຖວ . ຕັນ. sub|warnings.pm|
|27 |0.00054 |0.00002|ເສັ້ນ . ຕັນ. sub|overload.pm|
|9 |0.00047 |0.00005|ແຖວ . ຕັນ. sub|SelectSaver.pm|
|13 |0.00045 |0.00003|ແຖວ . ຕັນ. sub|File/Spec.pm |
|2701595|15.73869| |ທັງໝົດ |
|128647 |0.74946 | |ສະເລ່ຍ |
| |0.00201 |0.00003|ປານກາງ |
| |0.00121 |0.00003|ຄວາມບ່ຽງເບນ |

ບົດລາຍງານທີ່ຜະລິດໂດຍ NYTProf 2.03 Perl profiler, ພັດທະນາໂດຍ Tim Bunce ແລະ
ອາດາມ Kaplan.

ໃນຈຸດນີ້, ຖ້າທ່ານໃຊ້ html ບົດລາຍງານ, ທ່ານສາມາດຄລິກໃສ່ການເຊື່ອມຕໍ່ຕ່າງໆເພື່ອ
ເຈາະເຂົ້າໄປໃນແຕ່ລະ subroutine ແລະແຕ່ລະສາຍຂອງລະຫັດ. ເນື່ອງຈາກວ່າພວກເຮົາກໍາລັງໃຊ້ຂໍ້ຄວາມ
ລາຍງານຢູ່ທີ່ນີ້, ແລະມີໄດເລກະທໍລີທີ່ເຕັມໄປດ້ວຍບົດລາຍງານທີ່ສ້າງຂຶ້ນສໍາລັບແຕ່ລະໄຟລ໌ແຫຼ່ງ,
ພວກເຮົາພຽງແຕ່ຈະສະແດງສ່ວນຫນຶ່ງຂອງທີ່ສອດຄ້ອງກັນ wordmatch-line.html ໄຟລ໌, ພຽງພໍທີ່ຈະ
ໃຫ້ຄວາມຄິດຂອງການຈັດລຽງຂອງຜົນຜະລິດທີ່ທ່ານສາມາດຄາດຫວັງຈາກເຄື່ອງມືເຢັນນີ້.

$> html2text nytprof/wordmatch-line.html

ຂໍ້ມູນປະສິດທິພາບ --block view-.-line view-.-sub view-
ສໍາລັບ wordmatch
ດໍາເນີນການໃນວັນສຸກ 26 ກັນຍາ 13:46:39 2008
ລາຍງານວັນສຸກ ວັນທີ 26 ກັນຍາ 13:47:22 2008

ໄຟລ໌ຄໍາທີ່ກົງກັນ

ກິດຈະກຳຍ່ອຍ - ຈັດຮຽງຕາມເວລາສະເພາະ
|ການໂທ |P|F|ລວມ|ສະເພາະ|ລາຍການຍ່ອຍ|
| | | |ເວລາ |ເວລາ | |
|251215|5|1|13.09263 |10.47692 |main::|matches|
|260642|2|1|2.71199 |2.71199|ຫຼັກ::|ດີບັກ |
|1 |1|1|0.21404 |0.21404 |ຫຼັກ::|ບົດລາຍງານ |
|0 |0|0|0 |0 |ຕົ້ນຕໍ::|BEGIN |

|Line|Stmts.|Exclusive|Avg. |ລະຫັດ |
| | |ເວລາ | | |
|1| | | |#!/usr/bin/perl |
|2| | | | |
| | | | |ໃຊ້ຢ່າງເຂັ້ມງວດ; |
|3 |3 |0.00086 |0.00029|# ໃຊ້ເວລາ 0.00003s ໂທຫາ 1 ເທື່ອ:: |
| | | | |ນໍາເຂົ້າ |
| | | | | ການນໍາໃຊ້ຄໍາເຕືອນ; |
|4 |3 |0.01563 |0.00521|# ໃຊ້ເວລາ 0.00012s ໂທອອກຄຳເຕືອນ 1 ສາຍ:: |
| | | | |ນໍາເຂົ້າ |
|5| | | | |
|6| | | |=head1 NAME |
|7| | | | |
|8| | | |filewords - ການວິເຄາະຄໍາຂອງໄຟລ໌ປ້ອນຂໍ້ມູນ |
<...snip...>
|62 |1 |0.00445 |0.00445|ພິມບົດລາຍງານ( %count ); |
| | | | |# ໃຊ້ເວລາ 0.21404s ໂທຫາ 1 ສາຍຫາຫຼັກ::ລາຍງານ|
|63| | | | |
| | | | |# ໃຊ້ຈ່າຍ 23.56955s (10.47692+2.61571) ພາຍໃນ |
| | | | |ຕົ້ນຕໍ::ການຈັບຄູ່ທີ່ຖືກເອີ້ນວ່າ 251215 ຄັ້ງ, |
| | | | |avg 0.00005s/ໂທ: #50243 ຄັ້ງ |
| | | | |(2.12134+0.51939s) ຢູ່ແຖວ 57 ຂອງ wordmatch, avg|
| | | | |0.00005s/call #50243 ຄັ້ງ (2.17735+0.54550s) |
|64| | | |ຢູ່ແຖວ 56 ຂອງ wordmatch, avg 0.00005s/call # |
| | | | |50243 ເທື່ອ (2.10992+0.51797s) ຢູ່ແຖວ 58 ຂອງ |
| | | | |wordmatch, ສະເລ່ຍ 0.00005s/ໂທ #50243 ເທື່ອ |
| | | | |(2.12696+0.51598s) ຢູ່ແຖວ 55 ຂອງ wordmatch, avg|
| | | | |0.00005s/call #50243 ຄັ້ງ (1.94134+0.51687s) |
| | | | |ຢູ່ແຖວ 54 ຂອງ wordmatch, avg 0.00005s/call |
| | | | |sub matches { |
<...snip...>
|102| | | | |
| | | | |# ໃຊ້ເວລາ 2.71199s ພາຍໃນ main::debug ຊຶ່ງເປັນ |
| | | | |ໂທ 260642 ເທື່ອ, ສະເລ່ຍ 0.00001s/ໂທ: # |
| | | | |251215 ເວລາ (2.61571+0s) ໂດຍຫຼັກ::ການແຂ່ງຂັນຢູ່ທີ່ |
|103| | | |line 74 ຂອງ wordmatch, avg 0.00001s/call #9427 |
| | | | |ເວລາ (0.09628+0s) ຢູ່ແຖວ 50 ຂອງ wordmatch, avg|
| | | | |0.00001s/ໂທ |
| | | | |sub debug { |
|104 |260642|0.58496 |2e-06 |my $message = shift; |
|105| | | | |
|106 |260642|1.09917 |4e-06 |if ($debug ) { |
|107| | | |ພິມ STDERR "DBG: $message\n"; |
|108| | | |}|
|109| | | |}|
|110| | | | |
|111 |1 |0.01501 |0.01501|ອອກ 0; |
|112| | | | |

Oodles ຂອງຂໍ້ມູນທີ່ເປັນປະໂຫຍດຫຼາຍຢູ່ໃນນັ້ນ - ນີ້ເບິ່ງຄືວ່າເປັນວິທີທາງຕໍ່ໄປ.

ເບິ່ງ "Devel::NYTProf::Apache" ເຊິ່ງເຊື່ອມຕໍ່ "Devel::NYTProf" ເຂົ້າໄປໃນ "mod_perl".

ກຳ ລັງຈັດຮຽງ

ໂມດູນ Perl ບໍ່ແມ່ນເຄື່ອງມືດຽວທີ່ນັກວິເຄາະປະສິດທິພາບມີຢູ່ໃນການກໍາຈັດຂອງພວກເຂົາ, ລະບົບ
ເຄື່ອງມືເຊັ່ນ "ເວລາ" ບໍ່ຄວນຖືກມອງຂ້າມເປັນຕົວຢ່າງຕໍ່ໄປສະແດງໃຫ້ເຫັນ, ບ່ອນທີ່ພວກເຮົາໃຊ້ເວລາ a
ເບິ່ງໄວໃນການຈັດລຽງ. ປຶ້ມຫຼາຍຫົວ, ເຫຼົ່ານີ້ ແລະບົດຄວາມ, ໄດ້ຖືກຂຽນກ່ຽວກັບປະສິດທິພາບ
ການຈັດລຽງ algorithms, ແລະນີ້ບໍ່ແມ່ນສະຖານທີ່ທີ່ຈະເຮັດຊ້ໍາການເຮັດວຽກດັ່ງກ່າວ, ມີຫຼາຍທີ່ດີ
ການຈັດຮຽງໂມດູນທີ່ສົມຄວນພິຈາລະນາເຊັ່ນດຽວກັນ: "Sort::Maker", "Sort::Key" ພາກຮຽນ spring to
ໃຈ. ຢ່າງໃດກໍ່ຕາມ, ມັນຍັງເປັນໄປໄດ້ທີ່ຈະເຮັດໃຫ້ການສັງເກດການບາງຢ່າງກ່ຽວກັບ Perl ສະເພາະ
ການຕີລາຄາກ່ຽວກັບບັນຫາທີ່ກ່ຽວຂ້ອງກັບການຈັດລຽງຊຸດຂໍ້ມູນແລະໃຫ້ຕົວຢ່າງຫຼືສອງກັບ
ກ່ຽວກັບການຈັດລຽງປະລິມານຂໍ້ມູນຂະຫນາດໃຫຍ່ສາມາດມີຜົນກະທົບການປະຕິບັດ. ປະການທໍາອິດ, ເລື້ອຍໆ
ຈຸດທີ່ຖືກມອງຂ້າມໃນເວລາທີ່ຈັດລຽງຂໍ້ມູນຈໍານວນຫລາຍ, ຄົນເຮົາສາມາດພະຍາຍາມຫຼຸດຜ່ອນຂໍ້ມູນ
ຖືກກໍານົດໃຫ້ຈັດການກັບແລະໃນຫຼາຍໆກໍລະນີ "grep()" ສາມາດເປັນປະໂຫຍດຫຼາຍເປັນຕົວກອງທີ່ງ່າຍດາຍ:

@data = ຈັດຮຽງ grep { /$filter/ } @incoming

ຄໍາສັ່ງເຊັ່ນນີ້ສາມາດຫຼຸດລົງຢ່າງຫຼວງຫຼາຍຂອງວັດສະດຸທີ່ຈະຈັດລຽງຕາມຕົວຈິງ
ໃນສະຖານທີ່ທໍາອິດ, ແລະບໍ່ຄວນຈະຖືກປະຕິເສດ lightly ເກີນໄປຢ່າງດຽວບົນພື້ນຖານຂອງຕົນ
ຄວາມລຽບງ່າຍ. ຫຼັກການ "KISS" ມັກຈະຖືກມອງຂ້າມ - ຕົວຢ່າງຕໍ່ໄປໃຊ້ the
ລະບົບງ່າຍດາຍ "ເວລາ" ຜົນປະໂຫຍດເພື່ອສະແດງໃຫ້ເຫັນ. ໃຫ້ພິຈາລະນາຕົວຢ່າງຕົວຈິງຂອງ
ການຈັດຮຽງເນື້ອໃນຂອງໄຟລ໌ຂະຫນາດໃຫຍ່, ໄຟລ໌ບັນທຶກ apache ຈະເຮັດ. ອັນນີ້ມີຫຼາຍກວ່າ
ໄຕຣມາດຂອງນຶ່ງລ້ານເສັ້ນ, ມີຂະໜາດ 50M, ແລະສ່ວນຫຍໍ້ຂອງມັນເບິ່ງຄືດັ່ງນີ້:

# 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 (ເຂົ້າກັນໄດ້; 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 (ເຂົ້າກັນໄດ້; 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] "GET /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- ສະຫະລັດ; rv:1.8.1.1) Gecko/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 (ເຂົ້າກັນໄດ້; MSIE 6.0; Windows NT 5.1; SV1)"
217.113.68.60 - [08/Feb/2007:13:02:16 +0000] "GET /data/css HTTP/1.1" 404 206"http://www.rfi.net/" "Mozilla/4.0 (ເຂົ້າກັນໄດ້; 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 (ເຂົ້າກັນໄດ້; Konqueror/3.4; Linux) KHTML/3.4.0 (ຄືກັບ Gecko)"
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 (ເຂົ້າກັນໄດ້; Konqueror/3.4; Linux) KHTML/3.4.0 (ຄືກັບ Gecko)"
debora.to.isac.cnr.it - - [08/Feb/2007:13:03:58 +0000] "GET /favicon.ico HTTP/1.1" 404 209 "-" "Mozilla/5.0 (ເຂົ້າກັນໄດ້; Konqueror/ 3.4; Linux) KHTML/3.4.0 (ຄື Gecko)"
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) Gecko/1.5.0.9 Firefox/XNUMX"
195.24.196.99 - [08/Feb/2007:13:26:58 +0000] "GET /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) Gecko/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) Gecko/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 (ເຂົ້າກັນໄດ້; 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 (ເຂົ້າກັນໄດ້; 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 (ເຂົ້າກັນໄດ້; MSIE 6.0; Windows NT 5.1 CLR; .1.1.4322.NET; .XNUMX)"
80.247.140.134 - [08/Feb/2007:13:57:37 +0000] "GET /data/css HTTP/1.1" 404 206"http://www.rfi.net" "Mozilla/4.0 (ເຂົ້າກັນໄດ້; 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 ການຕັ້ງຄ່າ/CLDC-1.1"

ວຽກງານສະເພາະນີ້ແມ່ນເພື່ອຈັດຮຽງ 286,525 ແຖວຂອງໄຟລ໌ນີ້ໂດຍ Response Code, Query,
ຕົວທ່ອງເວັບ, ອ້າງອີງ Url, ແລະສຸດທ້າຍວັນທີ. ການແກ້ໄຂຫນຶ່ງອາດຈະເປັນການໃຊ້ລະຫັດຕໍ່ໄປນີ້,
ເຊິ່ງ iterates ໃນໄລຍະໄຟລ໌ທີ່ໃຫ້ຢູ່ໃນເສັ້ນຄໍາສັ່ງ.

# sort-apache-log

#!/usr/bin/perl -n

ໃຊ້ຢ່າງເຄັ່ງຄັດ;
ການນໍາໃຊ້ຄໍາເຕືອນ;

@data ຂອງຂ້ອຍ;

ເສັ້ນ:
ໃນຂະນະທີ່ ( <> ) {
$line ຂອງຂ້ອຍ = $_;
ຖ້າ (
$line =~ m/^(
([\w\.\-]+) # ລູກຄ້າ
\s*-\s*-\s*\[
([^]]+) # ວັນທີ
\]\s*"\w+\s*
(\S+) # ຄຳຖາມ
[^"]+"\s*
(\d+) # ສະຖານະ
\s+\S+\s+"[^"]*"\s+"
([^"]*) # browser
"
.*
)$/x
) {
my @chunks = ແຍກ(/ +/, $line);
$ip ຂອງຂ້ອຍ = $1;
$date ຂອງຂ້ອຍ = $2;
$query ຂອງຂ້ອຍ = $3;
ສະຖານະພາບ $ ຂອງຂ້ອຍ = $4;
$browser ຂອງຂ້ອຍ = $5;

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

ຂອງຂ້ອຍ @sorted = ການຈັດລຽງ {
$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 ຂອງຂ້ອຍ $data ( @sorted ) {
ພິມ $data->[5];
}

ອອກຈາກ 0;

ໃນເວລາທີ່ການດໍາເນີນງານໂຄງການນີ້, redirect "STDOUT" ສະນັ້ນມັນເປັນໄປໄດ້ທີ່ຈະກວດສອບຜົນໄດ້ຮັບແມ່ນ
ແກ້ໄຂຈາກການຕິດຕາມການທົດສອບແລ່ນແລະນໍາໃຊ້ "ເວລາ" utility ຂອງລະບົບເພື່ອກວດກາເບິ່ງໂດຍລວມ
ເວລາແລ່ນ.

$> ເວລາ ./sort-apache-log logfile > out-sort

ຕົວຈິງ 0m17.371s
ຜູ້ໃຊ້ 0m15.757s
sys 0m0.592s

ໂຄງການໃຊ້ເວລາພຽງແຕ່ຫຼາຍກວ່າ 17 ວິນາທີ wallclock ເພື່ອດໍາເນີນການ. ສັງເກດຄ່າທີ່ແຕກຕ່າງກັນ "ເວລາ"
ຜົນໄດ້ຮັບ, ມັນເປັນສິ່ງສໍາຄັນທີ່ຈະໃຊ້ອັນດຽວກັນສະເຫມີ, ແລະບໍ່ສັບສົນວ່າແຕ່ລະຄົນແມ່ນຫຍັງ
ໝາຍ ຄວາມວ່າ.

ເວລາຈິງທີ່ຜ່ານໄປແລ້ວ
ໂດຍລວມ, ຫຼື wallclock, ເວລາລະຫວ່າງເວລາທີ່ "ເວລາ" ຖືກເອີ້ນ, ແລະເວລາທີ່ມັນ
ຢຸດຕິ. ເວລາຜ່ານໄປລວມມີທັງເວລາຂອງຜູ້ໃຊ້ ແລະລະບົບ, ແລະເວລາທີ່ໃຊ້
ລໍຖ້າຜູ້ໃຊ້ແລະຂະບວນການອື່ນໆໃນລະບົບ. ແນ່ນອນວ່າ, ນີ້ແມ່ນຫຼາຍທີ່ສຸດ
ປະມານການວັດແທກທີ່ໃຫ້.

ເວລາ CPU ຂອງຜູ້ໃຊ້
ເວລາຂອງຜູ້ໃຊ້ແມ່ນຈໍານວນເວລາທີ່ຂະບວນການທັງຫມົດໃຊ້ໃນນາມຂອງຜູ້ໃຊ້
ລະບົບນີ້ປະຕິບັດໂຄງການນີ້.

ເວລາ CPU ຂອງລະບົບ
ເວລາຂອງລະບົບແມ່ນຈໍານວນເວລາທີ່ kernel ຕົວມັນເອງໃຊ້ເວລາປະຕິບັດການປົກກະຕິ, ຫຼື
ການໂທລະບົບ, ໃນນາມຂອງຜູ້ໃຊ້ຂະບວນການນີ້.

ດໍາເນີນການຂະບວນການດຽວກັນກັບ "ການຫັນເປັນ Schwarzian" ມັນເປັນໄປໄດ້ທີ່ຈະລົບລ້າງການ
input ແລະ output arrays ສໍາລັບການເກັບຮັກສາຂໍ້ມູນທັງຫມົດ, ແລະເຮັດວຽກກ່ຽວກັບການປ້ອນຂໍ້ມູນໂດຍກົງເປັນມັນ
ມາຮອດຄືກັນ. ຖ້າບໍ່ດັ່ງນັ້ນ, ລະຫັດມີລັກສະນະຄ້າຍຄືກັນ:

# sort-apache-log-schwarzian

#!/usr/bin/perl -n

ໃຊ້ຢ່າງເຄັ່ງຄັດ;
ການນໍາໃຊ້ຄໍາເຕືອນ;

ພິມ

ແຜນທີ່ $_->[0] =>

ຈັດລຽງ {
$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]
}
ແຜນທີ່ [$_, m/^(
([\w\.\-]+) # ລູກຄ້າ
\s*-\s*-\s*\[
([^]]+) # ວັນທີ
\]\s*"\w+\s*
(\S+) # ຄຳຖາມ
[^"]+"\s*
(\d+) # ສະຖານະ
\s+\S+\s+"[^"]*"\s+"
([^"]*) # browser
"
.*
)$/xo ]

=> <> ;

ອອກຈາກ 0;

ແລ່ນລະຫັດໃຫມ່ຕໍ່ກັບ logfile ດຽວກັນ, ດັ່ງຂ້າງເທິງ, ເພື່ອກວດເບິ່ງເວລາໃຫມ່.

$> ເວລາ ./sort-apache-log-schwarzian logfile > out-schwarz

ຕົວຈິງ 0m9.664s
ຜູ້ໃຊ້ 0m8.873s
sys 0m0.704s

ເວລາໄດ້ຖືກຕັດລົງເຄິ່ງຫນຶ່ງ, ເຊິ່ງເປັນການປັບປຸງຄວາມໄວທີ່ຫນ້າເຄົາລົບໂດຍມາດຕະຖານໃດກໍ່ຕາມ.
ຕາມທໍາມະຊາດ, ມັນເປັນສິ່ງສໍາຄັນທີ່ຈະກວດເບິ່ງຜົນຜະລິດແມ່ນສອດຄ່ອງກັບການດໍາເນີນໂຄງການທໍາອິດ,
ນີ້ແມ່ນບ່ອນທີ່ລະບົບ Unix "cksum" utility ເຂົ້າມາ.

$> cksum out-sort out-schwarz
3044173777 52029194 ອອກ-ຄັດ
3044173777 52029194 ອອກ-schwarz

BTW. ລະວັງເກີນໄປຂອງຄວາມກົດດັນຈາກຜູ້ຈັດການທີ່ເຫັນວ່າທ່ານເລັ່ງໂຄງການໂດຍ 50% ຂອງ
runtime ຄັ້ງດຽວ, ພຽງແຕ່ໄດ້ຮັບການຮ້ອງຂໍຫນຶ່ງເດືອນຕໍ່ມາເຮັດເຊັ່ນດຽວກັນ (ເລື່ອງຈິງ) -
ທ່ານພຽງແຕ່ຈະຕ້ອງຊີ້ໃຫ້ເຫັນວ່າເຈົ້າເປັນມະນຸດເທົ່ານັ້ນ, ເຖິງແມ່ນວ່າທ່ານເປັນໂປລແກລມ Perl, ແລະ
ເຈົ້າຈະເຫັນສິ່ງທີ່ເຈົ້າສາມາດເຮັດໄດ້...

ການບັນທຶກ

ພາກສ່ວນທີ່ສໍາຄັນຂອງຂະບວນການພັດທະນາທີ່ດີແມ່ນການຈັດການຄວາມຜິດພາດທີ່ເຫມາະສົມກັບ
ຂໍ້ຄວາມທີ່ເຫມາະສົມ, ຢ່າງໃດກໍຕາມມີໂຮງຮຽນຂອງຄວາມຄິດທີ່
ແນະນໍາວ່າໄຟລ໌ບັນທຶກຄວນຈະເປັນ ສົນທະນາ, ເປັນຖ້າຫາກວ່າລະບົບຕ່ອງໂສ້ຂອງຜົນຜະລິດ unbroken somehow
ຮັບປະກັນຄວາມຢູ່ລອດຂອງໂຄງການ. ຖ້າຄວາມໄວຢູ່ໃນບັນຫາໃດກໍ່ຕາມ, ວິທີການນີ້ແມ່ນ
ຜິດ

ການເບິ່ງເຫັນທົ່ວໄປແມ່ນລະຫັດທີ່ມີລັກສະນະຄ້າຍຄືນີ້:

logger->debug( "ຂໍ້ຄວາມບັນທຶກຜ່ານ process-id: $$ INC: " . dumper(\%INC) )

ບັນຫາແມ່ນວ່າລະຫັດນີ້ຈະຖືກວິເຄາະແລະປະຕິບັດສະເຫມີ, ເຖິງແມ່ນວ່າໃນເວລາທີ່ການດີບັກ
ລະດັບທີ່ກໍານົດໄວ້ໃນໄຟລ໌ການຕັ້ງຄ່າການບັນທຶກແມ່ນສູນ. ເມື່ອ ດີບັກ() subroutine ໄດ້
ເຂົ້າໄປ, ແລະຕົວແປ $debug ພາຍໃນໄດ້ຢືນຢັນວ່າເປັນສູນ, ຕົວຢ່າງ, ຂໍ້ຄວາມ
ທີ່ຖືກສົ່ງໄປແລ້ວຈະຖືກຍົກເລີກແລະໂຄງການຈະສືບຕໍ່. ໃນຕົວຢ່າງ
ຢ່າງໃດກໍຕາມ, "\%INC" hash ຈະຖືກຖິ້ມແລ້ວ, ແລະຂໍ້ຄວາມ
ການກໍ່ສ້າງ, ທັງຫມົດທີ່ເຮັດວຽກສາມາດຖືກຂ້າມຜ່ານຕົວແປ debug ໃນຄໍາຖະແຫຼງການ
ລະດັບ, ແບບນີ້:

logger->debug( "ຂໍ້ຄວາມບັນທຶກຜ່ານ process-id: $$ INC: " . dumper(\%INC) ) ຖ້າ $DEBUG;

ຜົນກະທົບນີ້ສາມາດສະແດງໃຫ້ເຫັນໄດ້ໂດຍການຕັ້ງຄ່າສະຄິບທົດສອບທີ່ມີທັງສອງຮູບແບບ, ລວມທັງ a
"debug()" ໂປຣເຈັກຍ່ອຍເພື່ອເຮັດຕາມການທໍາງານຂອງ "logger()" ປົກກະຕິ.

# ifdebug

#!/usr/bin/perl

ໃຊ້ຢ່າງເຄັ່ງຄັດ;
ການນໍາໃຊ້ຄໍາເຕືອນ;

ໃຊ້ Benchmark;
ໃຊ້ຂໍ້ມູນ::Dumper;
$DEBUG ຂອງຂ້ອຍ = 0;

ແກ້ບັນຫາຍ່ອຍ {
$msg ຂອງຂ້ອຍ = shift;

ຖ້າ ( $DEBUG ) {
ພິມ "DEBUG: $msg\n";
}
};

ເວລາເຫຼົ່ານີ້(100000, {
'ດີບັກ' => ຍ່ອຍ {
debug( "ຂໍ້ຄວາມບັນທຶກ A $0 ຜ່ານ process-id: $$". Dumper(\%INC) )
},
'ifdebug' => ຍ່ອຍ {
debug( "ຂໍ້ຄວາມບັນທຶກ A $0 ຜ່ານ process-id: $$". Dumper(\%INC) ) ຖ້າ $DEBUG
},
});

ມາເບິ່ງວ່າ "Benchmark" ແມ່ນຫຍັງ:

$> perl ifdebug
Benchmark: ກໍານົດເວລາ 100000 iterations ຂອງຄົງທີ່, sub...
ifdebug: 0 wallclock secs (0.01 usr + 0.00 sys = 0.01 CPU) @ 10000000.00/s (n=100000)
(ຄຳເຕືອນ: ການຊໍ້າຄືນໜ້ອຍເກີນໄປສຳລັບການນັບທີ່ເຊື່ອຖືໄດ້)
debug: 14 ໂມງຕິດຝາ (13.18 usr + 0.04 sys = 13.22 CPU) @ 7564.30/s (n=100000)

ໃນກໍລະນີຫນຶ່ງ, ລະຫັດ, ເຊິ່ງເຮັດຄືກັນອ້ອຍຕ້ອຍເທົ່າທີ່ outputting ໃດ
ຂໍ້ມູນ debugging ແມ່ນເປັນຫ່ວງ, ໃນຄໍາສັບຕ່າງໆອື່ນໆບໍ່ມີຫຍັງ, ໃຊ້ເວລາ 14 ວິນາທີ, ແລະໃນ
ກໍລະນີອື່ນລະຫັດໃຊ້ເວລາຫນຶ່ງຮ້ອຍຂອງວິນາທີ. ເບິ່ງຄືວ່າມີຄວາມຊັດເຈນພໍສົມຄວນ. ໃຊ້ ກ
ຕົວແປ $DEBUG ກ່ອນທີ່ທ່ານຈະໂທຫາ routine ຍ່ອຍ, ແທນທີ່ຈະອີງໃສ່ smart
ການທໍາງານພາຍໃນມັນ.

ການຕັດໄມ້ທ່ອນ if ດີບັກ (ຄົງທີ່)
ມັນເປັນໄປໄດ້ທີ່ຈະເອົາແນວຄວາມຄິດທີ່ຜ່ານມາຕື່ມອີກເລັກນ້ອຍ, ໂດຍໃຊ້ເວລາລວບລວມ "DEBUG"
ຄົງທີ່.

# ifdebug-ຄົງທີ່

#!/usr/bin/perl

ໃຊ້ຢ່າງເຄັ່ງຄັດ;
ການນໍາໃຊ້ຄໍາເຕືອນ;

ໃຊ້ Benchmark;
ໃຊ້ຂໍ້ມູນ::Dumper;
ໃຊ້ຄົງທີ່
DEBUG => 0
;

ແກ້ບັນຫາຍ່ອຍ {
ຖ້າ (ດີບັກ) {
$msg ຂອງຂ້ອຍ = shift;
ພິມ "DEBUG: $msg\n";
}
};

ເວລາເຫຼົ່ານີ້(100000, {
'ດີບັກ' => ຍ່ອຍ {
debug( "ຂໍ້ຄວາມບັນທຶກ A $0 ຜ່ານ process-id: $$". Dumper(\%INC) )
},
'ຄົງ' => ຍ່ອຍ {
debug( "ຂໍ້ຄວາມບັນທຶກ A $0 ຜ່ານ process-id: $$". Dumper(\%INC) ) ຖ້າ DEBUG
},
});

ການດໍາເນີນງານໂຄງການນີ້ຜະລິດຕະພັນດັ່ງຕໍ່ໄປນີ້:

$> perl ifdebug-ຄົງທີ່
Benchmark: ກໍານົດເວລາ 100000 iterations ຂອງຄົງທີ່, sub...
ຄົງທີ່: 0 wallclock secs (-0.00 usr + 0.00 sys = -0.00 CPU) @ -7205759403792793600000.00/s (n=100000)
(ຄຳເຕືອນ: ການຊໍ້າຄືນໜ້ອຍເກີນໄປສຳລັບການນັບທີ່ເຊື່ອຖືໄດ້)
ຍ່ອຍ: 14 ໂມງປຸກວິນາທີ (13.09 usr + 0.00 sys = 13.09 CPU) @ 7639.42/s (n = 100000)

ຄົງທີ່ "DEBUG" ເຊັດພື້ນດ້ວຍຕົວແປ $debug, ຢູ່ໃນຈຸດລົບ.
ສູນວິນາທີ, ແລະສ້າງຂໍ້ຄວາມ "ຄຳເຕືອນ: ຊໍ້າຄືນໜ້ອຍເກີນໄປສຳລັບການນັບທີ່ເຊື່ອຖືໄດ້".
ເຂົ້າໄປໃນການຕໍ່ລອງ. ເພື່ອເບິ່ງວ່າມີຫຍັງເກີດຂຶ້ນແທ້ໆ, ແລະເປັນຫຍັງພວກເຮົາຈຶ່ງມີເວລາຊໍ້າຄືນໜ້ອຍເກີນໄປ
ພວກເຮົາຄິດວ່າພວກເຮົາຂໍ 100000, ພວກເຮົາສາມາດໃຊ້ "B::Deparse" ທີ່ເປັນປະໂຫຍດຫຼາຍເພື່ອກວດກາເບິ່ງໃຫມ່.
ລະຫັດ:

$> perl -MO=ເຊົາ ifdebug-constant

ໃຊ້ Benchmark;
ໃຊ້ຂໍ້ມູນ::Dumper;
ໃຊ້ຄົງທີ່ ('DEBUG', 0);
ແກ້ບັນຫາຍ່ອຍ {
ການນໍາໃຊ້ຄໍາເຕືອນ;
ໃຊ້ 'refs' ທີ່ເຄັ່ງຄັດ;
0;
}
ການນໍາໃຊ້ຄໍາເຕືອນ;
ໃຊ້ 'refs' ທີ່ເຄັ່ງຄັດ;
timethese(100000, {'ຍ່ອຍ', ຍ່ອຍ {
debug "ຂໍ້ຄວາມບັນທຶກ $0 ຜ່ານ process-id: $$". Dumper(\%INC);
}
, 'ຄົງທີ່', ຍ່ອຍ {
0;
}
});
ifdebug-constant syntax ຕົກລົງ

ຜົນໄດ້ຮັບສະແດງໃຫ້ເຫັນ ຄົງທີ່() subroutine ທີ່ພວກເຮົາກໍາລັງທົດສອບຖືກແທນທີ່ດ້ວຍມູນຄ່າຂອງ
ຄົງທີ່ "DEBUG": ສູນ. ເສັ້ນທີ່ຈະທົດສອບໄດ້ຖືກປັບປຸງຢ່າງສົມບູນທັນທີ, ແລະ
ທ່ານບໍ່ສາມາດໄດ້ຮັບປະສິດທິພາບຫຼາຍກ່ວານັ້ນ.

ໂພສສະຄຣິບ

ເອກະສານນີ້ໄດ້ໃຫ້ຫຼາຍວິທີໃນການກໍານົດຈຸດຮ້ອນ, ແລະການກວດສອບ
ບໍ່ວ່າຈະເປັນການດັດແປງໃດກໍ່ໄດ້ປັບປຸງເວລາແລ່ນຂອງລະຫັດ.

ໃນຖານະເປັນຄວາມຄິດສຸດທ້າຍ, ຈົ່ງຈື່ໄວ້ວ່າມັນບໍ່ແມ່ນ (ໃນເວລາຂຽນ) ເປັນໄປໄດ້ທີ່ຈະຜະລິດ a
ໂຄງການທີ່ເປັນປະໂຫຍດທີ່ຈະດໍາເນີນການໃນເວລາສູນຫຼືທາງລົບແລະຫຼັກການພື້ນຖານນີ້ສາມາດເປັນ
ຂຽນເປັນ: ທີ່ເປັນປະໂຫຍດ ໂຄງການ ມີ ຊ້າ ໂດຍຄໍານິຍາມຂອງເຂົາເຈົ້າ. ມັນເປັນໄປໄດ້ແນ່ນອນ
ການຂຽນໂປຼແກຼມເກືອບທັນທີ, ແຕ່ມັນຈະບໍ່ເຮັດຫຼາຍ, ນີ້ແມ່ນຫຼາຍ
ຫນຶ່ງປະສິດທິພາບ:

$> perl -e 0

ການເພີ່ມປະສິດທິພາບທີ່ເພີ່ມເຕີມແມ່ນວຽກສໍາລັບ "p5p".

ໃຊ້ perlperf ອອນໄລນ໌ໂດຍໃຊ້ບໍລິການ onworks.net