Manière la plus simple de profiler un script PHP

Quelle est la façon la plus simple de profiler un script PHP?

J'adorerais ajouter quelque chose qui me montre un vidage de tous les appels de fonction et combien de temps ils ont pris, mais je suis également d'accord pour mettre quelque chose autour de fonctions spécifiques.

J'ai essayé d'expérimenter la fonction microtime :

$then = microtime();
myFunc();
$now = microtime();

echo sprintf("Elapsed:  %f", $now-$then);

mais cela me donne parfois des résultats négatifs. De plus, c'est beaucoup de mal à saupoudrer cela sur tout mon code.

L' extension PECL APD est utilisée comme suit:

<?php
apd_set_pprof_trace();

//rest of the script
?>

Ensuite, analysez le fichier généré à l'aide de pprofp.

Exemple de sortie:

Trace for /home/dan/testapd.php
Total Elapsed Time = 0.00
Total System Time  = 0.00
Total User Time    = 0.00


Real         User        System             secs/    cumm
%Time (excl/cumm)  (excl/cumm)  (excl/cumm) Calls    call    s/call  Memory Usage Name
--------------------------------------------------------------------------------------
100.0 0.00 0.00  0.00 0.00  0.00 0.00     1  0.0000   0.0009            0 main
56.9 0.00 0.00  0.00 0.00  0.00 0.00     1  0.0005   0.0005            0 apd_set_pprof_trace
28.0 0.00 0.00  0.00 0.00  0.00 0.00    10  0.0000   0.0000            0 preg_replace
14.3 0.00 0.00  0.00 0.00  0.00 0.00    10  0.0000   0.0000            0 str_replace

Avertissement: la dernière version d'APD est datée de 2004, l'extension n'est plus maintenue et présente divers problèmes de compatibilité (voir commentaires).

Tu veux xdebug je pense. Installez-le sur le serveur, allumez-le, pompez la sortie via kcachegrind (pour linux) ou wincachegrind (pour windows) et il vous montrera quelques jolis graphiques qui détaillent les horaires exacts, les nombres et l'utilisation de la mémoire (mais vous besoin d'une autre extension pour cela).

Ça berce, sérieusement: D

Aucune extension n'est nécessaire, utilisez simplement ces deux fonctions pour un profilage simple.

// Call this at each point of interest, passing a descriptive string
function prof_flag($str)
{
    global $prof_timing, $prof_names;
    $prof_timing[] = microtime(true);
    $prof_names[] = $str;
}

// Call this when you're done and want to see the results
function prof_print()
{
    global $prof_timing, $prof_names;
    $size = count($prof_timing);
    for($i=0;$i<$size - 1; $i++)
    {
        echo "<b>{$prof_names[$i]}</b><br>";
        echo sprintf("&nbsp;&nbsp;&nbsp;%f<br>", $prof_timing[$i+1]-$prof_timing[$i]);
    }
    echo "<b>{$prof_names[$size-1]}</b><br>";
}

Voici un exemple, appelant prof_flag () avec une description à chaque point de contrôle, et prof_print () à la fin:

prof_flag("Start");

   include '../lib/database.php';
   include '../lib/helper_func.php';

prof_flag("Connect to DB");

   connect_to_db();

prof_flag("Perform query");

   // Get all the data

   $select_query = "SELECT * FROM data_table";
   $result = mysql_query($select_query);

prof_flag("Retrieve data");

   $rows = array();
   $found_data=false;
   while($r = mysql_fetch_assoc($result))
   {
       $found_data=true;
       $rows[] = $r;
   }

prof_flag("Close DB");

   mysql_close();   //close database connection

prof_flag("Done");
prof_print();

La sortie ressemble à ceci:

Démarrer
   0,004303
Se connecter à la base de données
   0,003518
Effectuer la requête
   0,000308
Récupérer les données
   0,000009
Fermer la base de données
   0,000049
Terminé

Cross poster ma référence à partir de la version bêta de la documentation SO qui est hors ligne.

Profilage avec XDebug

Une extension de PHP appelée Xdebug est disponible pour aider au profilage des applications PHP , ainsi qu'au débogage d'exécution. Lors de l'exécution du profileur, la sortie est écrite dans un fichier au format binaire appelé "cachegrind". Des applications sont disponibles sur chaque plateforme pour analyser ces fichiers. Aucune modification du code d'application n'est nécessaire pour effectuer ce profilage.

Pour activer le profilage, installez l'extension et ajustez les paramètres php.ini. Certaines distributions Linux sont livrées avec des packages standard (par exemple le php-xdebugpackage d'Ubuntu ). Dans notre exemple, nous exécuterons le profil facultativement en fonction d'un paramètre de demande. Cela nous permet de garder les paramètres statiques et d'activer le profileur uniquement si nécessaire.

# php.ini settings
# Set to 1 to turn it on for every request
xdebug.profiler_enable = 0
# Let's use a GET/POST parameter to turn on the profiler
xdebug.profiler_enable_trigger = 1
# The GET/POST value we will pass; empty for any value
xdebug.profiler_enable_trigger_value = ""
# Output cachegrind files to /tmp so our system cleans them up later
xdebug.profiler_output_dir = "/tmp"
xdebug.profiler_output_name = "cachegrind.out.%p"

Utilisez ensuite un client Web pour faire une demande à l'URL de votre application que vous souhaitez profiler, par exemple

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

Au fur et à mesure que la page traite, elle écrit dans un fichier avec un nom similaire à

/tmp/cachegrind.out.12345

Par défaut, le numéro dans le nom de fichier est l'identifiant du processus qui l'a écrit. Ceci est configurable avec lexdebug.profiler_output_name paramètre.

Notez qu'il écrira un fichier pour chaque requête / processus PHP exécuté. Ainsi, par exemple, si vous souhaitez analyser une publication de formulaire, un profil sera écrit pour la demande GET pour afficher le formulaire HTML. Le paramètre XDEBUG_PROFILE devra être passé dans la demande POST suivante pour analyser la deuxième demande qui traite le formulaire. Par conséquent, lors du profilage, il est parfois plus facile d'exécuter curl pour POSTER directement un formulaire.

Analyse de la sortie

Une fois écrit, le cache de profil peut être lu par une application telle que KCachegrind ou Webgrind . PHPStorm, un IDE PHP populaire, peut également afficher ces données de profilage .

KCachegrind, par exemple, affichera des informations, notamment:

• Fonctions exécutées
• Temps d'appel, à la fois lui-même et incluant les appels de fonction ultérieurs
• Nombre de fois que chaque fonction est appelée
• Graphiques d'appel
• Liens vers le code source

Ce qu'il faut chercher

De toute évidence, l'optimisation des performances est très spécifique aux cas d'utilisation de chaque application. En général, il est bon de rechercher:

• Appels répétés à la même fonction que vous ne vous attendez pas à voir. Pour les fonctions qui traitent et interrogent les données, cela pourrait être une excellente opportunité pour votre application de mettre en cache.
• Fonctions à fonctionnement lent. Où l'application passe-t-elle la plupart de son temps? le meilleur gain dans l'optimisation des performances se concentre sur les parties de l'application qui consomment le plus de temps.

Remarque : Xdebug, et en particulier ses fonctionnalités de profilage, sont très gourmandes en ressources et ralentissent l'exécution PHP. Il est recommandé de ne pas les exécuter dans un environnement de serveur de production.

Si la soustraction de microtimes vous donne des résultats négatifs, essayez d'utiliser la fonction avec l'argument true( microtime(true)). Avec true, la fonction renvoie un flottant au lieu d'une chaîne (comme elle le fait si elle est appelée sans arguments).

Honnêtement, je vais faire valoir que l'utilisation de NewRelic pour le profilage est la meilleure.

C'est une extension PHP qui ne semble pas du tout ralentir le temps d'exécution et ils font la surveillance pour vous, permettant une exploration décente. Dans la version onéreuse, ils permettent une analyse approfondie (mais nous ne pouvons pas nous permettre leur modèle de tarification).

Pourtant, même avec le plan gratuit / standard, il est évident et simple où la plupart des fruits suspendus sont. J'aime aussi le fait que cela puisse aussi vous donner une idée sur les interactions DB.

Profilage du pauvre, aucune extension requise. Prend en charge les profils imbriqués et le pourcentage du total:

function p_open($flag) {
    global $p_times;
    if (null === $p_times)
        $p_times = [];
    if (! array_key_exists($flag, $p_times))
        $p_times[$flag] = [ 'total' => 0, 'open' => 0 ];
    $p_times[$flag]['open'] = microtime(true);
}

function p_close($flag)
{
    global $p_times;
    if (isset($p_times[$flag]['open'])) {
        $p_times[$flag]['total'] += (microtime(true) - $p_times[$flag]['open']);
        unset($p_times[$flag]['open']);
    }
}

function p_dump()
{
    global $p_times;
    $dump = [];
    $sum  = 0;
    foreach ($p_times as $flag => $info) {
        $dump[$flag]['elapsed'] = $info['total'];
        $sum += $info['total'];
    }
    foreach ($dump as $flag => $info) {
        $dump[$flag]['percent'] = $dump[$flag]['elapsed']/$sum;
    }
    return $dump;
}

Exemple:

<?php

p_open('foo');
sleep(1);
p_open('bar');
sleep(2);
p_open('baz');
sleep(3);
p_close('baz');
sleep(2);
p_close('bar');
sleep(1);
p_close('foo');

var_dump(p_dump());

Rendements:

array:3 [
  "foo" => array:2 [
    "elapsed" => 9.000766992569
    "percent" => 0.4736904954747
  ]
  "bar" => array:2 [
    "elapsed" => 7.0004580020905
    "percent" => 0.36841864946596
  ]
  "baz" => array:2 [
    "elapsed" => 3.0001420974731
    "percent" => 0.15789085505934
  ]
]

PECL XHPROF semble également intéressant. Il a une interface HTML cliquable pour afficher les rapports et une documentation assez simple . Je dois encore le tester.

J'aime utiliser phpDebug pour le profilage. http://phpdebug.sourceforge.net/www/index.html

Il génère toute l'utilisation du temps / de la mémoire pour tout SQL utilisé ainsi que tous les fichiers inclus. De toute évidence, cela fonctionne mieux sur du code abstrait.

Pour le profilage des fonctions et des classes, je vais simplement utiliser microtime()+ get_memory_usage()+ get_peak_memory_usage().

J'essaierais avec défi BlackFire .

Il y a cette virtualBox que j'ai composée à l' aide de puphpet , pour tester différents frameworks php qui viennent avec BlackFire, n'hésitez pas à forker et / ou distribuer si nécessaire :)

https://github.com/webit4me/PHPFrameworks

Pour l'analyse comparative, comme dans votre exemple, j'utilise le package pear Benchmark . Vous définissez des marqueurs pour mesurer. La classe fournit également quelques assistants de présentation, ou vous pouvez traiter les données comme bon vous semble.

Je l'ai en fait enveloppé dans une autre classe avec une méthode __destruct. Lorsqu'un script se termine, la sortie est enregistrée via log4php dans syslog, j'ai donc beaucoup de données de performance à partir desquelles je peux travailler.

XDebug n'est pas stable et n'est pas toujours disponible pour une version php particulière. Par exemple, sur certains serveurs, je lance toujours php-5.1.6, - c'est ce qui vient avec RedHat RHEL5 (et btw reçoit toujours des mises à jour pour tous les problèmes importants), et le récent XDebug ne compile même pas avec ce php. J'ai donc fini par passer au débogueur DBG. Son benchmark php fournit le timing des fonctions, des méthodes, des modules et même des lignes.

Vous devriez certainement vérifier ce nouveau profileur php.

https://github.com/NoiseByNorthwest/php-spx

Il redéfinit la façon dont les profileurs php collectent et présentent le résultat. Au lieu de générer uniquement un nombre total d'appels de fonction particuliers et le temps total passé à l'exécuter - PHP-SPX présente l'intégralité de la chronologie de l'exécution de la demande d'une manière parfaitement lisible. Voici l'écran de l'interface graphique qu'il fournit.