Il modo più semplice per profilare uno script PHP

Qual è il modo più semplice per profilare uno script PHP?

Mi piacerebbe affrontare qualcosa che mi mostra una discarica di tutte le chiamate di funzione e quanto tempo hanno impiegato, ma sto anche bene nel mettere qualcosa intorno a funzioni specifiche.

Ho provato a sperimentare la funzione microtime :

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

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

ma a volte ciò mi dà risultati negativi. Inoltre, è un sacco di problemi spargerlo su tutto il mio codice.

L' estensione APD PECL viene utilizzata come segue:

<?php
apd_set_pprof_trace();

//rest of the script
?>

Successivamente, analizzare il file generato utilizzando pprofp.

Esempio di output:

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

Attenzione: l'ultima versione di APD è datata 2004, l'estensione non è più mantenuta e presenta vari problemi di compatibilità (vedi commenti).

Vuoi xdebug, penso. Installalo sul server, accendilo , pompa l'output tramite kcachegrind (per Linux) o Wincachegrind (per Windows) e ti mostrerà alcuni graziosi grafici che dettagliano i tempi esatti, i conteggi e l'uso della memoria (ma serve un'altra estensione per quello).

Oscilla, sul serio: D

Non sono necessarie estensioni, basta usare queste due funzioni per una semplice profilazione.

// 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>";
}

Ecco un esempio, chiamando prof_flag () con una descrizione per ciascun checkpoint e prof_print () alla fine:

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();

L'output è simile al seguente:

Avvia
   0,004303
Connetti a DB
   0,003518
Esegui query
   0,000308
Recupera dati
   0,000009
Chiudi DB
   0,000049
Fine

Pubblicazione incrociata del mio riferimento dalla documentazione beta SO che non è in linea.

Profilazione con XDebug

Un'estensione di PHP chiamata Xdebug è disponibile per assistere nella creazione di profili di applicazioni PHP , nonché nel debug di runtime. Quando si esegue il profiler, l'output viene scritto in un file in un formato binario chiamato "cachegrind". Le applicazioni sono disponibili su ciascuna piattaforma per analizzare questi file. Non sono necessarie modifiche al codice dell'applicazione per eseguire questa profilazione.

Per abilitare il profiling, installa l'estensione e regola le impostazioni di php.ini. Alcune distribuzioni Linux vengono fornite con pacchetti standard (ad esempio il php-xdebugpacchetto Ubuntu ). Nel nostro esempio eseguiremo il profilo facoltativamente in base a un parametro di richiesta. Questo ci consente di mantenere le impostazioni statiche e attivare il profiler solo se necessario.

# 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"

Quindi utilizzare un client Web per effettuare una richiesta all'URL dell'applicazione che si desidera profilare, ad es

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

Man mano che la pagina viene elaborata, verrà scritta in un file con un nome simile a

/tmp/cachegrind.out.12345

Per impostazione predefinita, il numero nel nome file è l'id del processo che lo ha scritto. Questo è configurabile con l' xdebug.profiler_output_nameimpostazione.

Nota che scriverà un file per ogni richiesta / processo PHP che viene eseguito. Ad esempio, se si desidera analizzare un post di un modulo, verrà scritto un profilo per la richiesta GET per visualizzare il modulo HTML. Il parametro XDEBUG_PROFILE dovrà essere passato alla successiva richiesta POST per analizzare la seconda richiesta che elabora il modulo. Pertanto, quando si profila, a volte è più semplice eseguire curl per inviare direttamente un modulo.

Analizzare l'uscita

Una volta scritta, la cache del profilo può essere letta da un'applicazione come KCachegrind o Webgrind . PHPStorm, un famoso IDE PHP, può anche visualizzare questi dati di profilazione .

KCachegrind, ad esempio, mostrerà informazioni tra cui:

• Funzioni eseguite
• Tempo di chiamata, sia esso stesso che comprensivo delle successive chiamate di funzione
• Numero di volte in cui viene chiamata ciascuna funzione
• Grafici di chiamata
• Collegamenti al codice sorgente

Cosa cercare

Ovviamente l'ottimizzazione delle prestazioni è molto specifica per i casi d'uso di ciascuna applicazione. In generale è bene cercare:

• Chiamate ripetute per la stessa funzione che non ti aspetteresti di vedere. Per le funzioni che elaborano e interrogano i dati, queste potrebbero essere le principali opportunità per la cache dell'applicazione.
• Funzioni a funzionamento lento. Dove trascorre la maggior parte del tempo l'applicazione? il miglior risultato nell'ottimizzazione delle prestazioni è concentrarsi su quelle parti dell'applicazione che consumano più tempo.

Nota : Xdebug, e in particolare le sue funzionalità di profilazione, richiedono molte risorse e rallentano l'esecuzione di PHP. Si consiglia di non eseguirli in un ambiente server di produzione.

Se la sottrazione dei microtimi ti dà risultati negativi, prova a utilizzare la funzione con l'argomento true(microtime(true) ). Con true, la funzione restituisce un float anziché una stringa (come succede se viene chiamata senza argomenti).

Onestamente, ho intenzione di sostenere che l'utilizzo di NewRelic per la profilazione è il migliore.

È un'estensione PHP che non sembra rallentare affatto il runtime e fanno il monitoraggio per te, consentendo un drill down decente. Nella versione costosa consentono un approfondimento approfondito (ma non possiamo permetterci il loro modello di prezzi).

Tuttavia, anche con il piano gratuito / standard, è ovvio e semplice dove si trova la maggior parte della frutta bassa. Mi piace anche che possa darti un'idea anche sulle interazioni tra DB.

Profilazione del povero uomo, nessuna estensione richiesta. Supporta profili nidificati e percentuale del totale:

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;
}

Esempio:

<?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());

I rendimenti:

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
  ]
]

Anche PECL XHPROF sembra interessante. Ha un'interfaccia HTML cliccabile per visualizzare i report e una documentazione piuttosto semplice . Devo ancora provarlo però.

Mi piace usare phpDebug per la profilazione. http://phpdebug.sourceforge.net/www/index.html

Emette tutto il tempo / utilizzo della memoria per qualsiasi SQL utilizzato, nonché tutti i file inclusi. Ovviamente, funziona meglio sul codice estratto.

Per la profilazione di funzioni e classi userò solo microtime()+ get_memory_usage()+ get_peak_memory_usage().

Darei con sfida BlackFire .

C'è questo virtualBox che ho messo insieme usando puphpet , per testare diversi framework php che funzionano con BlackFire, non esitate a fork e / o distribuire se necessario :)

https://github.com/webit4me/PHPFrameworks

Per il benchmarking, come nel tuo esempio, uso il pacchetto pera Benchmark . Si impostano i marker per la misurazione. La classe fornisce anche alcuni aiutanti di presentazione, oppure puoi elaborare i dati come ritieni opportuno.

In realtà l'ho avvolto in un'altra classe con un metodo __destruct. Quando esce uno script, l'output viene registrato tramite log4php su syslog, quindi ho molti dati sulle prestazioni su cui lavorare.

XDebug non è stabile e non è sempre disponibile per particolari versioni di php. Ad esempio su alcuni server eseguo ancora php-5.1.6, - è quello che viene fornito con RedHat RHEL5 (e tra l'altro riceve ancora aggiornamenti per tutti i problemi importanti), e XDebug recente non si compila nemmeno con questo php. Così sono finito con il passaggio al debugger DBG Il suo benchmarking php fornisce tempistiche per funzioni, metodi, moduli e persino linee.

Dovreste assolutamente controllare questo nuovo profiler php.

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

Ridefinisce il modo in cui i profiler php raccolgono e presentano il risultato. Invece di emettere solo un numero totale di chiamate di funzioni particolari e il tempo totale impiegato per eseguirla - PHP-SPX presenta l'intera sequenza temporale dell'esecuzione della richiesta in un modo perfettamente leggibile. Di seguito è la schermata della GUI che fornisce.