PHP კოდის პროფილირება. XHProf და xDebug - PHP კოდის პროფილირება დამატებითი თარჯიმნის პარამეტრების გამოყენებით

xhprof-ის ინსტალაცია php-სთვის:

Sudo apt-get დააინსტალირე php5-xhprof

გადატვირთეთ Apache:

Sudo სერვისის apache2 გადატვირთვა

დაბეჭდეთ phpinfo(); და შეამოწმე მოდული ჩართულია თუ არა?

ჩვენ ვამოწმებთ /etc/php5/apache2/conf.d, რათა დავინახოთ, გამოჩნდება თუ არა იქ xhprof.ini კონფიგურაციის ბმული.

თუ არა, მაშინ შექმენით ბმული თავად და გადატვირთეთ Apache.

Sudo ln -s /etc/php5/mods-available/xhprof.ini /etc/php5/apache2/conf.d/20-xhprof.ini sudo სერვისის apache2 გადატვირთვა

ჩვენ ვამოწმებთ xhprof კავშირს, ვამოწმებთ არის თუ არა დაკავშირებული 20-xhprof.ini:

სკრინშოტი აჩვენებს 0.9.2 ვერსიას, თუმცა ინსტალაციის დროს ნაჩვენები იყო ვერსია 0.9.4, მაგრამ ეს არ არის ჩვენთვის დაბრკოლება.

ახლა ჩვენ შეგვიძლია ჩვენი კოდის პროფილი.

  1. გვერდის დასაწყისში ჩართეთ პროფილირება xhprof_enable();
  2. გვერდის ბოლოს გამორთეთ პროფილირება xhprof_disable()-ის გამოყენებით და შეინახეთ შეგროვებული მონაცემები save_run();
  3. შემდეგ ვაანალიზებთ.

ფუნქცია xhprof_enable()არგუმენტად იღებს დროშებს:

XHPROF_FLAGS_CPU პროცესორის სტატისტიკის ჩასაწერად,

XHPROF_FLAGS_MEMORY - მეხსიერებისთვის,

XHPROF_FLAGS_NO_BUILTINS - ჩაშენებული ფუნქციების იგნორირება.

შესანახად და შემდგომი განხილვისთვის, ჩვენ უნდა დავაყენოთ პროფილის ანალიზის ინსტრუმენტი.

ჩამოტვირთეთ არქივი ანალიზის ხელსაწყოთი xhprof: გვერდიდან, მიიღეთ ვერსია 0.9.4.

სერვერზე ან ლოკალურ კომპიუტერზე, შექმენით საქაღალდე, რომელიც ხელმისაწვდომი იქნება ლოკალური ჰოსტის ან ცალკე დომენის საშუალებით, რომელშიც ჩვენ ვხსნით ჩამოტვირთულ არქივს:

ახლა ჩვენ შეგვიძლია პროფილის შენახვა.

https://xn--d1acnqm.xn--j1amh/altadmin/posts/edit/188

თვალთვალის კოდი ასე გამოიყურება:

// პროფილერის ინიცირება - ჩვენ ვითვლით როგორც პროცესორის დროს, ასევე მეხსიერების მოხმარებას xhprof_enable(XHPROF_FLAGS_CPU + XHPROF_FLAGS_MEMORY);
// პროფილირებული კოდი # Stop profiler $xhprof_data = xhprof_disable(); # შეინახეთ ანგარიში და შექმენით ბმული მის სანახავად include_once "/var/www/html/xhprof-0.9.4/xhprof_lib/utils/xhprof_lib.php"; include_once "/var/www/html/xhprof-0.9.4/xhprof_lib/utils/xhprof_runs.php"; $xhprof_runs = ახალი XHProfRuns_Default(); $run_id = $xhprof_runs->save_run($xhprof_data, "xhprof_test"); echo "ანგარიში: http://localhost/xhprof-0.9.4/xhprof_html/index.php?run=$run_id&source=xhprof_test"; ექო "\n";

/var/www/html/xhprof-0.9.4 - გზა იმ საქაღალდემდე, სადაც გავხსენით საჭირო ბიბლიოთეკები.

ანგარიში: http://localhost/xhprof-0.9.4/xhprof_html/index.php?run=57c32f3095d21&source=xhprof_test

ასე გამოიყურება პროფილის ანალიზი. ეს ცხრილი აჩვენებს ყველა ფუნქციის ზარს, რომელიც პროფილირებულია.

შეგვიძლია ფუნქციების დალაგება ცხრილის სათაურებზე დაწკაპუნებით.

როდესაც ვხედავთ, რომ რომელიმე ფუნქცია შესრულებულია ბევრჯერ ან ძალიან დიდი ხნის განმავლობაში, შეგვიძლია დავაწკაპუნოთ ამ ფუნქციაზე და გაიხსნება მსგავსი ცხრილი, მაგრამ შიდა ზარებით მოცემული ფუნქციის შიგნით და იმ მშობლის გარემოში, სადაც ფუნქცია გამოიძახეს.

ინდიკატორები:
Total Inc. Wall Time (ფუნქციების შესრულებაზე დახარჯული დრო, სოკეტების, ფაილური სისტემის და სხვა რესურსების პასუხების მოლოდინის გათვალისწინებით)
Total Inc. CPU (ფუნქციების შესრულებაზე დახარჯული დრო)
Total Inc. MemUse (მეხსიერების გამოყენება)
Total Inc. PeakMemUse (მეხსიერების მაქსიმალური გამოყენება)
ფუნქციის ზარების რაოდენობა

ასევე არსებობს ანგარიშის გრაფიკულად ჩვენების შესაძლებლობა. მაგრამ ამისათვის თქვენ უნდა დარწმუნდეთ, რომ დაინსტალირებული გაქვთ graphviz ბიბლიოთეკა:

Apt-get დააინსტალირეთ graphviz

შემდეგ თქვენს პროფილში თქვენ უნდა დააჭიროთ საჩვენებლად და voila:

ახლა თქვენ შეგიძლიათ გაანალიზოთ და გააუმჯობესოთ კოდი.

FirePHP არის firebug-ის გაფართოება, რომელიც თავის მცირე php კლასთან ერთად საშუალებას გაძლევთ გადაიტანოთ მონაცემები php-დან, მაგალითად, ყველა სახის var_dump და სხვა გამართვის ინფორმაცია, firebug კონსოლში ამ გაფართოების მთავარი უპირატესობა ის არის ყველა გამართვის ინფორმაცია გადაიცემა სათაურებით და არ აფუჭებს გვერდებს და არანაირად არ არღვევს აპლიკაციის ლოგიკას: http://firephp.org/.

Მთავარი იდეა.

ზოგადი პროფილის ალგორითმი შემდეგია:
  1. გვერდის დასაწყისში ჩართეთ პროფილირება xhprof_enable() გამოყენებით.
  2. გვერდის ბოლოს გამორთეთ პროფილირება xhprof_disable() გამოყენებით და შეინახეთ შეგროვებული მონაცემები save_run() გამოყენებით.
  3. შემდეგ, firephp php კლასის გამოყენებით, კლიენტის ნაწილს ვუგზავნით პროფილის მონაცემების ბმულს
  4. firebug კონსოლში ჩვენ ვხსნით საჭირო ინფორმაციას
  5. გვიხარია :)
მე ასევე მინდა ვთქვა, რომ, რა თქმა უნდა, ამ ფუნქციების ხელით დამატება თქვენს PHP სკრიპტებში შესანიშნავია. მაგრამ მე მინდა, რომ ეს ინფორმაცია ყოველთვის ხელთ იყოს განვითარების დროს და არ დასრულდეს წარმოების სერვერებზე. ჩვენ ამ პრობლემას ვაგვარებთ შემდეგნაირად:

ჩვენს პროექტებში, თითქმის ყველა სკრიპტში, დასაწყისში დაკავშირებულია სამუშაო ფაილი კლასის ჩამტვირთველით, დამაკავშირებელი ფუნქციებით და სხვა საჭირო ნივთებით. ამიტომ, ჩვენ ჩავრთეთ პროფილის ჩართვა ამ ფაილში. და იმისათვის, რომ სურვილისამებრ შეგვეძლოს გამართვის რეჟიმის ჩართვა/გამორთვა, ჩვენ დავამატეთ შემოწმება კონფიგურაციის მუდმივობისთვის, გარდა ამისა, ეს შემოწმებები გადავიტანეთ ზოგიერთ მეტატეგებში, რომლებიც ავტომატურად იშლება პროექტის აშენებისას. იგივე ეხება პროფილის გამორთვას და ინფორმაციის ჩაწერას სათაურებზე firephp-ის გამოყენებით - ეს ამოცანები წყდება ერთი ფუნქციით, რომელიც იწოდება ყოველი PHP სკრიპტის ბოლოს და ასევე შეფუთულია მეტა ტეგებში. ეს დაახლოებით ასე გამოიყურება:

// შემდეგი მუდმივები იწერება განაცხადის კონფიგურაციის ფაილში

/** გარემოს მუშაობის რეჟიმი * */
define("APPLICATION_ENV" , "dev" ); // dev - გამართვა | პრო - წარმოება
/** გზა პროფილირამდე */
define("XHPROF_ROOT", __DIR__. "/ExtProcs/debug/xhprof-0.9.2");

/***************************************************************************************
* შემდეგ, ფაილში, რომელიც იტვირთება თითოეული სკრიპტის დასაწყისში, ჩვენ ვიწყებთ პროფილირებას
* DEV_START და DEV_END ჩვენი მეტათეგებია, მათ შორის ყველაფერი ამოჭრილია შეკრების დროს
***************************************************************************************/

//-- DEV_START
//-- გამართვის რეჟიმში ვაკავშირებთ გამართვის ბიბლიოთეკებს

// ჩატვირთეთ firephp
მოითხოვს_ერთხელ (__DIR__ . "/includes/ExtProcs/debug/firephp/FirePHP.class.php");
//-- ჩატვირთეთ პროფილერი
"/xhprof_lib/utils/xhprof_lib.php");
მოითხოვს_ერთჯერ (XHPROF_ROOT. "/xhprof_lib/utils/xhprof_runs.php");
// პროფილირების ინიცირება საჭირო დროშებით. დროშების დეტალური აღწერა
// შეგიძლიათ იხილოთ php.net/manual/ru/xhprof.constants.php
xhprof_enable(XHPROF_FLAGS_CPU + XHPROF_FLAGS_MEMORY);
}
//-- DEV_END

// კარგად, ეს ფუნქცია იწოდება ყოველი სკრიპტის ბოლოს
// მისი ზარი ასევე შეფუთულია DEV_START და DEV_END

/**
* შექმენით პროფილის შედეგის ბმული და აჩვენეთ იგი კონსოლში
*/
ფუნქცია dev_boot_Down() (
თუ (APPLICATION_ENV === "dev") (
// firephp ინსტანციის ინიცირება
$firephp = FirePHP::getInstance(true);
// გამორთეთ პროფილირება და შეინახეთ მონაცემები
$xhprof_data = xhprof_disable();
$xhprof_runs = ახალი XHProfRuns_Default();
$run_id = $xhprof_runs->save_run($xhprof_data, "xhprof_testing" );
// შექმენით ბმული პროფილირების მონაცემებთან და ჩაწერეთ კონსოლში
$link = "http://" . $_SERVER["HTTP_HOST"] . "/includes/ExtProcs/debug/xhprof-0.9.2/xhprof_html/index.php?run=($run_id)&source=xhprof_testing\n";
$firephp->info($link, "პროფილის მონაცემები" );
}
}


* ეს საწყისი კოდი მონიშნული იყო Source Code Highlighter-ით.

მე არ შევუდგები ამ გაფართოებების დაყენების დეტალებს, რადგან აქ ყველაფერი მარტივია. მე ვიტყვი მხოლოდ დაყენების ზოგიერთ ასპექტზე. xhproof-ს აქვს მხოლოდ ერთი კონფიგურაციის ცვლადი - xhprof.output_dir, რომელიც მიუთითებს საქაღალდეზე, სადაც შეინახება პროფილირების მონაცემები. ამიტომ, დარწმუნდით, რომ მომხმარებელს, რომლის ქვეშაც შესრულებულია PHP სკრიპტები, აქვს ჩაწერის უფლება მითითებულ დირექტორიაში. ასე რომ, დაწერეთ მსგავსი რამ თქვენს php.ini-ში:


გაფართოება=xhprof.so
xhprof.output_dir="/var/tmp/xhprof"

ასევე კარგი იდეაა დააინსტალიროთ რაღაც წერტილის ან Graphviz-ის მსგავსი ზარის გრაფიკების დახატვა. მე მაქვს Graphviz MacOS X-ზე.

ზემოთ აღწერილი პროცედურების დასრულების შემდეგ, ჩვენ შეგვეძლო ნებისმიერ დროს გაგვეხსნა და შეგვენახა ჩვენი ნებისმიერი სკრიპტის პროფილირება პირდაპირ ბრაუზერში.

აპლიკაციის პროფილირება არის მონაცემთა შეგროვება პროგრამის სხვადასხვა განყოფილებების (ფაილები და ფუნქციები) შესრულების სიჩქარის შესახებ. არსებობს მრავალი PHP პროფილირების ინსტრუმენტი, მაგრამ ყველა ინსტრუმენტი არ არის შესაფერისი ანალიზის ჩასატარებლად უშუალოდ წარმოების ადგილზე.

XHProf და მისი ჩანგალი Tideways არის მოსახერხებელი და მარტივი პროფილერი, რომელსაც შეუძლია ეფექტურად შეაგროვოს სტატისტიკა აპლიკაციის მუშაობის შესახებ თქვენი აპლიკაციის (ან თქვენი ვებსაიტის) სიჩქარის თითქმის შემცირების გარეშე.

რატომ პროფილის კოდი?

თუ აპლიკაცია ნელა იწყებს მუშაობას (წაიკითხეთ „საიტმა დაიწყო შენელება“), პროფილირება საშუალებას მოგცემთ გაარკვიოთ რომელი ნაწილია ყველაზე ნელი. პროფილირების შედეგი, როგორც წესი, არის შესრულებული ფუნქციების სია მათი შესრულების დროს.

კოდის პროფილირება პირველ რიგში უნდა იყოს განაცხადის ოპტიმიზაციის პროცესში. ნებისმიერი სხვა იქნება ვარაუდი და დიდი ალბათობით არასწორი. თქვენ უნდა იცოდეთ ზუსტად რა იწვევს პრობლემებს და "მუხრუჭებს".

პროფილირება არის კოდის შესრულების დროის შესახებ სტატისტიკის შეგროვებისა და ორგანიზების პროცედურა. ეს არ არის ოპტიმიზაციის ან პროგრამის მოდიფიკაციის პროცესი. ამ პროცესის შედეგი, როგორც წესი, არის გაფართოებული ანგარიში პროგრამის კომპონენტებისა და ფუნქციების შესრულების სტატისტიკაზე.

ეს არის ზუსტად ის, რისთვისაც შეიქმნა XHProf გადაწყვეტა. ის შექმნილია რეალურ ვებსაიტებზე მუშაობისთვის. ამ პროფილერის მთავარი იდეაა აპლიკაციაზე მინიმალური დატვირთვის შექმნა, მუშაობის სიჩქარის შესახებ ყველა საჭირო მონაცემის შეგროვებისას. გამოსავალი შეიმუშავეს Facebook-ის სპეციალისტებმა.

როგორ დავაკავშიროთ php პროფილერი ავტომატურად?

ჩვენმა სპეციალისტებმა ბევრი იმუშავეს და ეს პროცესი სრულიად ავტომატიზირებული გახადეს.
თქვენ უბრალოდ უნდა შეხვიდეთ სისტემაში, შეარჩიოთ სასურველი დომენი "დომენების" ჩანართში, დააწკაპუნოთ ხატულაზე "PHP.INI + PHP Profiler" და ჩართოთ "Domain Profiler" ჩამრთველი.

ამ ფუნქციის ჩართვას შეიძლება გარკვეული დრო დასჭირდეს, ჩვეულებრივ არა უმეტეს 10 წუთისა.

php ვერსიებისთვის 5.2, 5.3, 5.4, 5.5, 5.6, 7.0 ვიყენებთ XHProf პროფილერს, php 7.1 და უფრო მაღალი ვერსიებისთვის ვიყენებთ Tideways პროფილერს.

ჩართვის შემდეგ, PHP-ის მიერ დამუშავებული თქვენი საიტის თითოეულ გვერდზე, მის ბოლოში ჩაშენდება სპეციალური ბლოკი ანგარიშის ფაილის ბმულებით (ბმული ასე გამოიყურება:

Domain-name.com/xhprof-master/xhprof_html/index.php?run=XXXXXXXXXXXX&source=someapp)

და ანგარიშის ფაილი ასე გამოიყურება:

ცხრილი შეიცავს ფუნქციების ჩამონათვალს, რომლებიც შესრულდა ერთ გვერდზე დამატებითი ინფორმაცია:

  • ზარები - ფუნქციის ზარების რაოდენობა და პროცენტი
  • ჩათვლით Wall Time - ფუნქციის შესრულების დრო ჩადგმული ფუნქციებით
  • გამოკლ. Wall Time - ფუნქციის შესრულების დრო წყობილი ფუნქციების გარეშე
  • ჩათვლით CPU - პროცესორის დრო ჩადგმული ფუნქციებით
  • გამოკლ. CPU - პროცესორის დრო ჩადგმული ფუნქციების გარეშე
  • ჩათვლით MemUse - მეხსიერების მოხმარება ჩადგმული ფუნქციებით
  • გამოკლ. MemUse - მეხსიერების მოხმარება ჩადგმული ფუნქციების გარეშე
  • ჩათვლით PeakMemUse - მეხსიერების მაქსიმალური მოხმარება ჩადგმული ფუნქციებით
  • გამოკლ. PeakMemUse - მეხსიერების მაქსიმალური მოხმარება ჩადგმული ფუნქციების გარეშე

უნდა აღინიშნოს, რომ მოქცევის გამოყენებით აგებული რეპორტაჟი შეიძლება ვიზუალურად ოდნავ განსხვავდებოდეს ამ მოხსენებისგან, მაგრამ არსი არ იცვლება.

გრაფიკული ანგარიშები


კოდის რესურსზე ინტენსიური სექციები მონიშნულია ყვითლად (საშუალო) და წითლად (ყველაზე მძიმე). ეს არის კოდის ის სექციები, რომლებიც იყენებენ უამრავ რესურსს პროგრამის დანარჩენთან შედარებით. ეს შეიძლება იყოს ერთი ნელი ფუნქცია ან მრავალი ზარი სწრაფ ფუნქციაზე. ჩვენს მაგალითში ვხედავთ, რომ mysqli_multi_query() ფუნქცია მონიშნულია წითლად, რადგან ის მუშაობს ყველაზე ნელა.

საერთო ანგარიშები

XHProf ინტერფეისი ასევე საშუალებას გაძლევთ ნახოთ ერთობლივი ინფორმაცია რამდენიმე მოხსენებიდან ერთდროულად. ამისათვის run_id გადაეცემა მძიმით გამოყოფილი:

Domain-name.com/xhprof-master/xhprof_html/index.php?run=XXXXXXXXXXXX,YYYYYYYYYYY&source=someapp

ტექნიკური მახასიათებლები

    პროფილერის ავტომატური ჩართვა ხორციელდება auto_append_file და auto_prepend_file დირექტივების გამოყენებით, რომლებიც აკავშირებენ ორ შესრულებად php ფაილს:

    — auto_append_file ახდენს სტატისტიკის შეგროვების ობიექტის ინიციალიზებას და იწყებს მუშაობას;

    — auto_prepend_file ასრულებს სტატისტიკის შეგროვებას და აგენერირებს ანგარიშის ფაილს სტატისტიკით (JSON ფორმატში);

    თუ exit() ან die() გამოიძახება სანამ თქვენი სკრიპტი მუშაობს, auto_prepend_file არ შესრულდება. სტატისტიკის ფაილი არ შეიქმნებადა ანგარიშის ფაილის ბმულებით ბლოკი არ იქნება ჩართული გვერდის ბოლოში.

  1. ამრიგად, php-ით დამუშავებულ ნებისმიერ გვერდზე წვდომა გამოიწვევს ახალი ანგარიშის ფაილის შექმნას, ამიტომ ჩვენ გირჩევთ გამორთოთ პროფილერი სტატისტიკის შეგროვების შემდეგ (ჩვეულებრივ რამდენიმე საათის განმავლობაში), რათა თავიდან აიცილოთ დისკის კვოტის გადაჭარბება, რომელიც შეიძლება ამოიწუროს გენერირების შემდეგ. მოხსენებების დიდი რაოდენობა!
  2. მნიშვნელოვანია: პროფილერი იმუშავებს მხოლოდ იმ შემთხვევაში, თუ საიტი მიმაგრებულია სერვერზე სტანდარტული ბილიკის საშუალებით, ავტომატური საშუალებებით (ანუ ჰოსტინგის მართვის პანელის გამოყენებით), წინააღმდეგ შემთხვევაში თქვენ უნდა დაუკავშირდეთ Hostland-ის ტექნიკურ მხარდაჭერას პროფილერის კონფიგურაციისთვის.
  3. ავტომატურ რეჟიმში პროფილერი უერთდება მხოლოდ მთავარ დომენის სახელს;
  4. ავტომატურ რეჟიმში პროფილერი აგროვებს სტატისტიკას მხოლოდ სკრიპტებისთვის გაფართოებით .php და .php5
  5. შეუძლებელია საიტის უწყვეტი მუშაობის გარანტია PHP პროფილერთან დაკავშირების შემდეგ, ამიტომ, თუ საიტი არ მუშაობს სწორად, სანამ პროფილერი ჩართულია, ის უნდა გამორთოთ და პროფილირება გაგრძელდეს სხვა გზით.

მოდით შევაჯამოთ

ვიმედოვნებთ, რომ ეს ინსტრუმენტი დაგეხმარებათ თქვენი საიტები კიდევ უფრო სწრაფად გახადოთ Hostland ჰოსტინგზე.

სტატიაში ნაწილობრივ გამოყენებული იქნა ვებსაიტზე განთავსებული მომხმარებლის Den Golotyuk-ის მასალები

მან აჩვენა, თუ როგორ უნდა დააინსტალიროთ და დააკონფიგურიროთ xdebug და მოიცავდა რამდენიმე ძირითად მახასიათებელს, როგორიცაა var_dump() ფუნქციის გამომუშავების გაუმჯობესება ან შეცდომის შეტყობინების მიღებისას ზარის სტეკის კვალის დაბეჭდვა. მეორე ნაწილში ჩვენ შევხედეთ ამ xdebug ფუნქციას, როგორც მოკვლევას. კვალი შეიცავს ყველა ზარს პროგრამაში ფუნქციებზე და მეთოდებზე, გაშვების დროს, სურვილისამებრ მეხსიერების ზომას, გადაცემულ და დაბრუნებულ პარამეტრებს. კვალის ჟურნალი დაგეხმარებათ გაიგოთ რთული პროგრამის შესრულების გზა. პროგრამის შიგნით გამართვის კოდის ჩასმის ნაცვლად, თქვენ ჩართავთ ან გამორთავთ მიკვლევას, სადაც საჭიროა, და შემდეგ იყენებთ კომუნალურ პროგრამებს, როგორიცაა grep ან თქვენი საკუთარი PHP აპლიკაციები ჟურნალის ფაილის გასაანალიზებლად.

ამ სტატიაში განვიხილავთ პროფილირებას. ერთი შეხედვით, პროფილირება ტრასინგის მსგავსია. პროფილირების ჟურნალი არ არის განკუთვნილი ადამიანებისთვის, ის არ არის გამიზნული პროგრამის ნაკადის ვიზუალიზაციისთვის, მაგრამ ის გვაწვდის მონაცემებს გაშვებული პროგრამის სტატისტიკური ანალიზისთვის.

პროფილირების ჟურნალის შექმნა

ქვემოთ მოცემულია მოკლე ამონაწერი xdebug-ის მიერ გენერირებული პროფილირების ჟურნალიდან:

fl=php:internal
fn=php::define
106 3

Fl=C:\www\drupal\includes\bootstrap.inc
fn=require_once::C:\www\drupal\includes\bootstrap.inc
1 648
cfn=php::define
ზარები = 1 0 0
13 6
cfn=php::define
ზარები = 1 0 0
18 4
cfn=php::define
ზარები = 1 0 0
23 2


როგორც ხედავთ, პროფილირების ჟურნალის პირდაპირ წაკითხვა შეუძლებელია. მიღებული მონაცემების ვიზუალიზაციისა და ანალიზისთვის გამოვიყენებთ დამატებით ინსტრუმენტებს. ასე რომ, პროფილირება გვიჩვენებს, რამდენჯერ იქნა გაშვებული კონკრეტული ხაზი და რამდენ ხანს დასჭირდა გაშვება.
პროფილირების ჟურნალის შექმნა მნიშვნელოვნად ამცირებს შესრულებას, ისევე როგორც კვალის ჟურნალის შექმნას, რადგან თქვენ უნდა აღწეროთ თითოეული ხაზის გავლა. ამიტომ, ისევე, როგორც ტრასინგის შემთხვევაში, ნუ აწარმოებთ პროფილირებას საწარმოო სერვერებზე... თუმცა არის შემთხვევები, როცა პროფილირება საჭიროა ლაივ სისტემაზე გაშვება. ამ შემთხვევაში, ფრთხილად იყავით xdebug-ის ერთდროულად გაშვებაზე Zend-ის სხვა გაფართოებებთან, როგორიცაა loaders, ოპტიმიზატორები ან ქეშები.
იმისათვის, რომ xdebug-მა დაიწყოს პროფილის ჟურნალების ჩაწერა, დაამატეთ

გთხოვთ გაითვალისწინოთ, რომ თქვენ არ შეგიძლიათ პროფილირების გაშვება გაშვების დროს ბრძანების გაშვებით.
იმის გამო, რომ პროფილირების ჟურნალი განკუთვნილია ანალიზატორის პროგრამების წასაკითხად, არ არსებობს დამატებითი პარამეტრები, რომლებიც საშუალებას მოგცემთ აჩვენოთ დამატებითი ინფორმაცია, როგორც ეს არის კვალის ჟურნალის შემთხვევაში. თუმცა, არის რამდენიმე პარამეტრი, რომელიც საშუალებას გაძლევთ დააკონფიგურიროთ პროფილირება, ისეთივე, როგორიც ჩვენ ვიყენებდით ტრასინგის დაყენებისას.
პირველ რიგში, xdebug წერს პროფილირების ჟურნალს /tmp დირექტორიაში ნაგულისხმევად. თუ იყენებთ Windows-ს, თქვენ უნდა დააფიქსიროთ php.ini, ასე:
xdebug.profiler_output_dir="c:\traces"

ნაგულისხმევად, xdebug გადაწერს არსებული პროფილირების ჟურნალს. თქვენ შეგიძლიათ დააკონფიგურიროთ ის, რომ შეავსოს არსებული, შემდეგი ბრძანების დამატებით

php.ini-ში. არის შემთხვევები, როდესაც არ გსურთ შექმნათ პროფილის ჟურნალი ყველა ფაილისთვის, მაგრამ ამავე დროს პროფილის გააქტიურება გაშვების დროს პრობლემურია. იმის ნაცვლად, რომ პერიოდულად ჩართოთ და გამორთოთ პროფილირება, დაამატეთ ბრძანება
xdebug.profiler_enable_trigger=ჩართული

php.ini-ში. ახლა თქვენ შეგიძლიათ ჩართოთ და გამორთოთ პროფილირება სპეციალური GET ან POST პარამეტრის XDEBUG_PROFILE PHP სკრიპტის გადაცემით. ეს საშუალებას მისცემს მხოლოდ ამ PHP სკრიპტის პროფილირებას. არ არის აუცილებელი ამ პარამეტრის მნიშვნელობის დაყენება, უბრალოდ დაიმახსოვრეთ, რომ დაამატოთ ეს პარამეტრი მისამართს test.php?XDEBUG_PROFILE.

პროფილის ჟურნალის სახელი

სახელი, რომელსაც xdebug ანიჭებს პროფილირების ჟურნალს ნაგულისხმევად არის „cachegrind.out“. პლუს პროცესის იდენტიფიკატორი. ისევე, როგორც კვალის ჟურნალის შემთხვევაში, შეგიძლიათ შეცვალოთ ჟურნალის სახელები php.ini-ზე შესაბამისი პარამეტრების დამატებით. პარამეტრის სახელი xdebug.profiler_output_name. არგუმენტი არის სტრიქონი. რომელიც შეიძლება შეიცავდეს სხვადასხვა მოდიფიკატორებს. ყველაზე მნიშვნელოვანი მათგანი ქვემოთ მოცემულია:

  • %p – პროცესის იდენტიფიკატორი
  • %r – შემთხვევითი რიცხვი
  • %u - დრო
  • %H – $_SERVER-ის ღირებულება[„HTTP_HOST“]
  • %R – $_SERVER-ის ღირებულება["REQUEST_URI"]
  • %s – სახელი სრული ბილიკის ჩათვლით, ხაზები გარდაიქმნება ქვედა ხაზებად
გთხოვთ, გაითვალისწინოთ, რომ %s მოდიფიკატორი გამოიყენება მხოლოდ xdebug.profiler_output_name-სთვის. თუ გსურთ გაიგოთ პროფილირების ჟურნალის სახელი, შეგიძლიათ დარეკოთ xdebug_get_profiler_filename() ფუნქცია.

პროფილირების ჟურნალის ანალიზი
როგორც ზემოთ აღინიშნა, პროფილირების ჟურნალის გასაანალიზებლად საჭიროა მონაცემთა ვიზუალიზაციის დამატებითი პროგრამები. ყველა პროფილირების ჟურნალი, რომელსაც xdebug ქმნის, არის Cachegrind ფორმატის მსგავსი ფორმატი. Cachegrind არის პროფილერი, რომელიც არის უფრო ძლიერი პროგრამის ნაწილი, სახელწოდებით Valgrind, პროგრამული უზრუნველყოფის გამართვისა და პროფილირების პროგრამა Linux-ისთვის. Cachegrind შეიქმნა ქეშის, მეხსიერების გამოყენებისა და პროგრამის ბრძანებების სტატისტიკის გასაანალიზებლად. კიდევ ერთი Valgrind ინსტრუმენტი, Callgrind, ხატავს ზარის გრაფიკებს. რაც შეეხება PHP-ს, ჩვენ შეგვიძლია გამოვიყენოთ ეს აპლიკაცია პროფილირების ჟურნალის ვიზუალიზაციისა და ანალიზისთვის.
ხელსაწყოს, რომელიც ჩვეულებრივ გამოიყენება xdebug-ის მიერ წარმოქმნილი პროფილირების ჟურნალის გასაანალიზებლად, ეწოდება . KCachegrind არის თავისუფალი პროგრამული უზრუნველყოფა, რომელიც ლიცენზირებულია GPL-ით (მუშაობს მხოლოდ Unix სისტემებზე). თუმცა Windows-ისთვის არის მარტივი პროგრამა, რომელიც ასევე უფასოა. ჯერ ვნახოთ ვინდოუსის ვერსია.

WinCacheGrind: Windows-ში პროფილირების ჟურნალების ანალიზი

WinCachegrind-ის მიმდინარე ვერსია (ამ სტატიის ავტორის მიერ წერის დროს) არის 1.0.0.12. ეს ვერსია 2005 წლით თარიღდება, რაც იმას ნიშნავს, რომ WinCachegrind დიდი ხანია არ არის შემუშავებული. თუ გადახედავთ გამოშვების ნოტებს, ავტორები წერენ, რომ პროგრამას აქვს შეცდომები, რომლებიც ზოგჯერ აიძულებს მას უცნაურად მოიქცეს.
ამიტომ, გირჩევთ გამოიყენოთ KCachegrind, რომელიც გაშვებულია ვირტუალური აპარატის საფუძველზე Linux-ის უახლეს დისტრიბუციაზე, მაგალითად Ubuntu (მთარგმნელის შენიშვნა, ზოგადად რომ ვთქვათ, უცნაური რეკომენდაციაა; ამ შემთხვევაში, მე გირჩევდი უბრალოდ Linux-ის დაყენებას და არა ღობეზე. ვირტუალური მანქანების ბაღი). Windows-ის ქვეშ არის ვირტუალური მანქანების დიდი რაოდენობა. თუ რაიმე მიზეზით შეუძლებელია Unix-ის ან ვირტუალური მანქანის გამოყენება, შეგიძლიათ გააგრძელოთ WinCachegrind-ის გამოყენება მარტივი პროფილის ჟურნალის ანალიზისთვის. WinCachegrind არ ხატავს ზარის გრაფიკებს, განსხვავებით KCachegrind.
Wincachegrind-ის დაყენება ძალიან მარტივია. გაუშვით ინსტალერი, დააჭირეთ ღილაკს ლიცენზიის მისაღებად და ინსტალაცია დასრულებულია. ახლა თქვენ შეგიძლიათ გაუშვათ პროგრამა და გახსნათ ერთ-ერთი cachegrind პროფილირების ჟურნალი, რომელიც შექმნილია xdebug-ის მიერ.

საათის ან სიგმას ხატულაზე დაწკაპუნებით, შეგიძლიათ გადახვიდეთ ინფორმაციის ჩვენებას შორის აბსოლუტური მნიშვნელობებით და პროცენტებით. პროცენტული ჩვენება გვიჩვენებს, რამდენი დრო, მთლიანი დროის პროცენტულად, სჭირდება მოცემულ ბლოკში ფუნქციის გამოძახებას.
ორი სასარგებლო პარამეტრია Profiler -> Hide Fast Functions და Profiler -> Hide Library Functions. პირველი გადამრთველი მალავს ფუნქციებს, რომელთა დროის წვლილი პროგრამის შესრულების მთლიან დროში უმნიშვნელოა.
მეორე პარამეტრი, Profiler -> Hide Library Functions, მალავს PHP-ში ჩაშენებულ ფუნქციებს ზოგადი ანალიზიდან. როდესაც ორივე ეს პარამეტრი ჩართულია, თქვენ ხედავთ ნაკლებ მონაცემს, რაც საშუალებას გაძლევთ ფოკუსირება მოახდინოთ თქვენი კოდის იმ სფეროებზე, რომლებსაც ოპტიმიზაცია სჭირდებათ.
მთავარი ფანჯარა შეიცავს ორ ჩანართს: სტრიქონ-სტრიქონი და საერთო. ორივე ჩანართი აჩვენებს ერთსა და იმავე ინფორმაციას, მაგრამ მთლიანი ჩანართი აგროვებს ინფორმაციას უკეთესი პრეზენტაციისთვის. Self time აჩვენებს კოდის გაშვების დროს მიმდინარე ბლოკში, ხოლო კუმულაციური დრო (Cum.) აჩვენებს მოცემულ ბლოკში ფუნქციების მთლიან გაშვების დროს.

KCacheGrind: პროფილირების ჟურნალების ანალიზი Unix-ში

KCachegrind-ის Unix ვერსია უზრუნველყოფს უფრო მეტ ფუნქციონირებას, ვიდრე WinCachegrind. KCachegrind ვიზუალიზებს მონაცემებს და აშენებს ზარის გრაფიკს.
მისი გამოყენების დასაწყებად, თქვენ უნდა დააინსტალიროთ KCachegrind. Მოქმედი ვერსია . უფრო ახალი ვერსია (0.10.1) ხელმისაწვდომია, მაგრამ ის Valgrind პაკეტის ნაწილია.
თუ შესაძლებელია, გამოიყენეთ პაკეტის მენეჯერი KCachegrind პაკეტის დასაყენებლად. KCachegrind იყენებს GraphViz-ს ზარის გრაფიკების დასახატავად, ამიტომ თქვენ ასევე უნდა დააინსტალიროთ GraphViz პაკეტი, თუ თქვენი პაკეტის მენეჯერი ავტომატურად არ დააინსტალირებს დამოკიდებულ პაკეტებს.
თუ ვერ იპოვით KCachegrind ორობით პაკეტს, თქვენ თავად მოგიწევთ KCachegrind-ის შედგენა. წყაროების ჩამოტვირთვის შემდეგ გაუშვით

./configure --prefix=/opt/kde3
გააკეთოს
დააინსტალირეთ

როგორც შენიშნეთ, თქვენ უნდა მიუთითოთ გზა KDE ბიბლიოთეკის მიმდინარე ინსტალაციისკენ. თუ არ იცით სად მდებარეობს თქვენს სისტემაში KDE ბიბლიოთეკები, გამოიყენეთ

KDE ბიბლიოთეკებისკენ მიმავალი ბილიკის ჩვენება.
ინსტალაციის შემდეგ, შეგიძლიათ გაუშვათ KCacheGrind ბრძანების ხაზიდან

მონაცემთა ცხრილური ჩვენება KCachegrind-ში ძალიან ჰგავს WinCachegrind-ს. თქვენ ასევე შეგიძლიათ გადახვიდეთ აბსოლუტურ და პროცენტულ მნიშვნელობებს შორის. KCachegrind-ის ზოგიერთი ფუნქცია არ არის შექმნილი PHP-სთვის. ქვემოთ მოცემულ სურათზე ნაჩვენებია phpMyAdmin პროგრამის ზარის გრაფიკი:


როგორც ხედავთ, გაშვების დროის უმეტესი ნაწილი დაიხარჯა common.inc.php-ში. შემდეგი სკრინშოტი აჩვენებს ფუნქციის გამოძახების ვიზუალიზაციას common.inc.php-ში:

კოდის ეს ბლოკი აწარმოებს ორ request_onces-ს, რაც არის იმ დროის ნახევარი, რაც სჭირდება common.inc.php-ის გასაშვებად. ორმაგი დაწკაპუნებით ნებისმიერ მართკუთხედზე უფრო ღრმად გადაგიყვანთ მონაცემთა ანალიზში.

კოდის ოპტიმიზაცია პროფილირების მონაცემებზე დაყრდნობით

ოპტიმიზაციამდე ყოველთვის დაწერეთ თქვენი აპლიკაციების პროფილი. თქვენ შეგიძლიათ დაიწყოთ ოპტიმიზაცია თავად, იმ ადგილას, სადაც მოგეჩვენებათ, რომ ეს ოპტიმიზაცია მოაქვს ეფექტს, მაგრამ ეს ყოველთვის ასე არ არის. ოპტიმიზაცია ძირითადად მოქმედებს მხოლოდ იმ ნაწილებზე, რომლებიც ყველაზე მეტ დროს ატარებენ შესრულების პროცესში.
თუ თქვენ ერთდროულად აწარმოებთ პროგრამის ბევრ ასლს, შესაძლოა მაინც დაგჭირდეთ თქვენი პროგრამის იმ ნაწილის ოპტიმიზაცია, რომელიც იკავებს შესრულების დროის უმეტეს ნაწილს. ამ შემთხვევაში, ოპტიმიზაცია არ დააჩქარებს ერთი ინდივიდუალური მოთხოვნის შესრულებას, მაგრამ ის საშუალებას მისცემს თქვენს სერვერს გაუმკლავდეს მაღალ დატვირთვას, ხოლო ნაკლებ რესურსს მოიხმარს ამ მოთხოვნების შესასრულებლად.
პროფილერის გაშვების ხანგრძლივობის დათვალიერებისას გაითვალისწინეთ, რომ აბსოლუტური მნიშვნელობები ნაკლებად მნიშვნელოვანია, ვიდრე ფარდობითი მნიშვნელობები. სხვადასხვა სისტემებზე გაზომილი, აბსოლუტური მნიშვნელობები შეიძლება განსხვავდებოდეს. თუმცა, სანამ თქვენი კოდის ოპტიმიზაციას დაიწყებთ, გაითვალისწინეთ შემდეგი რამ.
ოპტიმიზაციის მნიშვნელოვანი წესია I/O ოპერაციების რაოდენობის შემცირება. ზოგიერთი I/O ოპერაცია ძალიან შრომატევადია გამოთვლებთან შედარებით. ასეთი ოპერაციების შემცირება შეიძლება იყოს ძალიან ეფექტური გზა თქვენი პროგრამის დასაჩქარებლად. ერთი I/O ზარის წაშლა უფრო ეფექტურ გაუმჯობესებას იძლევა, ვიდრე კოდის ოპტიმიზაციისთვის ბევრი საათის დახარჯვა. ამიტომ, კოდირების დაწყებამდე ჯერ ყურადღება უნდა გაამახვილოთ I/O ოპერაციებზე.
თქვენ ასევე შეგიძლიათ გაზარდოთ თქვენი სერვერების რაოდენობა ოპტიმიზაციამდე. შეგიძლიათ შეიძინოთ უზარმაზარი, რომელიც მოგცემთ პროდუქტიულობის მცირე ზრდას. განვითარების დრო უფრო ძვირია, ვიდრე ახალი სერვერის ფასი. და თუ გაზრდით ტექნიკის რაოდენობას, შეგიძლიათ დარწმუნებული იყოთ, რომ ზრდას დაუყოვნებლივ მიიღებთ PHP კოდზე რაიმე ზემოქმედების გარეშე. როდესაც დეველოპერი ხარჯავს ერთ ან ორ დღეს კოდის ოპტიმიზაციას, ვერასოდეს გეტყვით, რამდენად გაიზრდება პროდუქტიულობა. და ბოლოს, თქვენ აღარ შეგიძლიათ დარწმუნებული იყოთ, რომ ოპტიმიზაცია არ მოიტანს შეცდომებს.
ზოგიერთი გვერდის სტატიკურ გვერდებზე გადაყვანა არის უკეთესი შესრულების მიღწევის ერთ-ერთი გზა. ვთქვათ, არის საიტი დიდი ტრაფიკით, სადაც PHP სკრიპტი ქმნის პირველ გვერდს თითოეული მოთხოვნისთვის, ირჩევს ინფორმაციას მონაცემთა ბაზიდან ან XML ფაილიდან. თუ გვერდის მონაცემები საკმაოდ ხშირად იცვლება, შეგიძლიათ ხელახლა შექმნათ მისი სტატიკური ასლი. თუ სტატიკურ ხედზე კონვერტაცია შეუძლებელია გვერდისთვის (ზოგიერთი პერსონალური ინფორმაცია ნაჩვენებია გვერდზე), შეგიძლიათ ზოგიერთი ბლოკის სტატიკურ ხედად გადაქცევა.
ოპტიმიზაციის სხვა დონე არ საჭიროებს PHP კოდის შეცვლას. როგორც ვიცით PHP არის ინტერპრეტირებული ენა. ეს ნიშნავს, რომ მისი ბრძანებები ითარგმნება გაშვების დროს შუალედურ კოდში. მაუწყებლობა მეორდება ყოველ ჯერზე სკრიპტის გაშვებისას. ეს ხდის PHP-ს ანელებს ისეთ ენებთან შედარებით, როგორიცაა C ან Java, რომლებიც არ საჭიროებენ კოდის გაანალიზებას ყოველ ჯერზე, როცა გაშვებთ. PHP-სთვის შეგიძლიათ გამოიყენოთ შუალედური წარმომადგენლობის ქეში (იხილეთ ჩემი თარგმანი...) შუალედური კოდის შესანახად და ხელახლა გამოსაყენებლად, ეს აჩქარებს გაშვებას და შესრულებას.
ეს ყველაფერი არ ნიშნავს იმას, რომ არ არის დრო ან ადგილი PHP კოდის ოპტიმიზაციისთვის. ზოგიერთი კოდის ოპტიმიზაციას შეუძლია მნიშვნელოვნად გააუმჯობესოს შესრულება. თუმცა, ყოველთვის გახსოვდეთ, რომ კოდის შეცვლა ყოველთვის შეიცავს დამატებითი შეცდომების და უსაფრთხოების საკითხების დანერგვის რისკს. ასევე გახსოვდეთ, რომ თქვენი კოდის ოპტიმიზაცია მას ნაკლებად იკითხავს.

დასკვნა

პროფილირების ჟურნალის შექმნა და ვიზუალიზაცია ერთ-ერთი მნიშვნელოვანი პირობაა PHP კოდის ოპტიმიზაციისთვის. თქვენ უნდა იცოდეთ პროგრამის რომელ ადგილებს სჭირდებათ ყველაზე მეტი დრო და სწორედ აქედან უნდა დაიწყოთ ოპტიმიზაცია.
შემდეგ სტატიაში განვიხილავთ xdebug-ის გამოყენებით გამართვას. xdebug-ს შეუძლია მოგაწოდოთ დისტანციური გამართვის შესაძლებლობა. კლიენტის გამოყენებით, რომელსაც აქვს ეს შესაძლებლობა, როგორიცაა Eclipse PDT, შეგიძლიათ გამართოთ თქვენი კოდი მისი შეცვლის გარეშე, დააყენოთ წყვეტის წერტილები, გადახვიდეთ კოდის სექციებში და ნახოთ, როგორ და სად ცვლის ცვლადები მნიშვნელობებს.

PHP-ის გაფართოება სახელწოდებით Xdebug ხელმისაწვდომია PHP აპლიკაციების პროფილირების დასახმარებლად, ასევე გაშვების დროში გამართვისთვის. პროფილერის გაშვებისას, გამოსავალი იწერება ფაილში ორობით ფორმატში, სახელწოდებით "cachegrind". აპლიკაციები ხელმისაწვდომია თითოეულ პლატფორმაზე ამ ფაილების გასაანალიზებლად. ამ პროფილის შესასრულებლად განაცხადის კოდის ცვლილებები არ არის საჭირო.

პროფილირების ჩასართავად დააინსტალირეთ გაფართოება და შეცვალეთ php.ini პარამეტრები. Linux-ის ზოგიერთ დისტრიბუციას გააჩნია სტანდარტული პაკეტები (მაგ. Ubuntu-ს php-xdebug პაკეტი, ჩვენ შევძლებთ პროფილს სურვილისამებრ შევინარჩუნოთ მოთხოვნის პარამეტრი და ჩავრთოთ პროფილერი მხოლოდ საჭიროებისამებრ.

# php.ini settings # დააყენეთ 1-ზე, რომ ჩართოთ იგი ყოველი მოთხოვნისთვის xdebug.profiler_enable = 0 # მოდით გამოვიყენოთ GET/POST პარამეტრი პროფილის ჩასართავად xdebug.profiler_enable_trigger = 1 # GET/POST მნიშვნელობა ჩვენ გადავცემთ ; ნებისმიერი მნიშვნელობისთვის xdebug.profiler_enable_trigger_value = "" # გამოიტანეთ cachegrind ფაილები /tmp-ზე, რათა ჩვენი სისტემა ასუფთავებს მათ მოგვიანებით xdebug.profiler_output_dir = "/tmp" xdebug.profiler_output_name = "cachegrind.out.%p"

შემდეგ გამოიყენეთ ვებ კლიენტი თქვენი აპლიკაციის URL-ზე მოთხოვნის გასაკეთებლად, რომლის პროფილიც გსურთ, მაგ.

Http://example.com/article/1?XDEBUG_PROFILE=1

როგორც გვერდი ამუშავებს, ის ჩაიწერს ფაილში მსგავსი სახელით

/tmp/cachegrind.out.12345

ნაგულისხმევად, ფაილის სახელის ნომერი არის პროცესის ID, რომელმაც დაწერა იგი. ამის კონფიგურირება შესაძლებელია xdebug.profiler_output_name პარამეტრით.

გაითვალისწინეთ, რომ ის დაწერს ერთ ფაილს თითოეული შესრულებული PHP მოთხოვნისთვის/პროცესისთვის. ასე რომ, მაგალითად, თუ გსურთ ფორმის პოსტის ანალიზი, ერთი პროფილი დაიწერება GET მოთხოვნისთვის HTML ფორმის ჩვენებისთვის. XDEBUG_PROFILE პარამეტრი უნდა გადავიდეს შემდგომ POST მოთხოვნაში მეორე მოთხოვნის გასაანალიზებლად, რომელიც ამუშავებს ფორმას. ამიტომ, პროფილირებისას, ზოგჯერ უფრო ადვილია ფორმაზე პირდაპირ POST-ზე გაშვება.

გამოყვანის ანალიზი

დაწერის შემდეგ, პროფილის ქეში შეიძლება წაიკითხოს ისეთი აპლიკაციით, როგორიცაა Webgrind. PHPStorm, პოპულარული PHP IDE, ასევე შეუძლია ამ პროფილის მონაცემების ჩვენება.

KCachegrind, მაგალითად, აჩვენებს ინფორმაციას, მათ შორის:

  • შესრულებული ფუნქციები
  • ზარის დრო, როგორც თავად, ასევე შემდგომი ფუნქციის ზარების ჩათვლით
  • თითოეული ფუნქციის გამოძახების რაოდენობა
  • ზარის გრაფიკები
  • ბმულები წყაროს კოდზე

რა უნდა ვეძებოთ

ცხადია, შესრულების tuning ძალიან სპეციფიკურია თითოეული აპლიკაციის გამოყენების შემთხვევისთვის. ზოგადად კარგია მოძებნოთ:

  • განმეორებითი ზარები იმავე ფუნქციაზე, რომლის ნახვასაც არ მოელით ფუნქციებისთვის, რომლებიც ამუშავებენ და მოითხოვენ მონაცემებს, ეს შეიძლება იყოს თქვენი აპლიკაციის ქეშირების მთავარი შესაძლებლობა.
  • ნელი მუშაობის ფუნქციები. სად ატარებს აპლიკაცია დროის უმეტეს ნაწილს? შესრულების ტუნინგში საუკეთესო ანაზღაურება არის აპლიკაციის იმ ნაწილებზე ფოკუსირება, რომლებიც ყველაზე მეტ დროს ხარჯავენ.

შენიშვნა: Xdebug და, კერძოდ, მისი პროფილირების ფუნქციები, ძალიან რესურსი ინტენსიურია და ანელებს PHP-ის შესრულებას. რეკომენდირებულია არ გაუშვათ ისინი წარმოების სერვერის გარემოში.