[CONTEST] Tuning PHP Performance

[daniele_dll]

Ho cercato di trovare un titolo adatto perché penso che questo contest possa essere utile a tanti!

A chi è più avanti nell'uso di PHP sarà di certo capitato di doversi scontrare con le pessime performance che si riescono ad ottenere da questo linguaggio di programmazione! Performance, le più delle volte, ottenute pensando di scrivere buon codice anche se in realtà per php non lo era abbastanza.

Per performance non intendo solo velocità di esecuzione ma anche memoria utilizzata: meno memoria viene utilizzata dal codice più pagine potranno essere eseguite senza che venga utilizzato lo swap del sistema

Con questo non voglio dire che le performance sono tutto, ma che comunque sono importanti per ottenere dei buoni lavori: se un vostro cliente deve aspettare un secondo per la creazione della pagina, più il download dei contenuti, è facile che a lung'andare si secchi a causa dell'aumentare della latenza per via dell'incremento dei dati presenti nel sistema.

Il contest è ovviamente aperto a tutti, non c'è alcun tipo di limitazione, l'importante è seguire alcuni semplici regole:
1° Prima di postare il vostro codice accertatevi che non c'è ne sia uno uguale
2° Se trovate del codice che fa la stessa cosa, invece di postare il vostro, prendete quello, modificatelo per come credete meglio, ed inserite il vostro nome tra gli autori, questo eviterà inutili test estremamente simili
3° Il punto 2°, ovviamente, non è valido se il vostro test e quelli simili che avete trovato tendono ad identificare aspetti diversi
4° TUTTO il codice che postate, cosa quindi accettata implicitamente al momento del posting nel thread, deve essere sotto licenza BSD, questo affinche il codice possa essere, in un secondo momento, inserito in un database e ed essere convertito in unità di testing gestite da un sistema centralizzato

Il quarto punto, anche se è l'ultimo, non lo è per importanza: lo scopo di questo contest è quello di fornire un servizio utile a tutti ed è quindi necessario che il codice sia sotto una licenza aperta, e la licenza BSD lo è veramente tanto!

Passando a fatti più concreti: il codice che verrà postato si dovrà occupare di eseguire N iterazioni, per N si intende un numero variabile, su M sistemi diversi per fare una stessa cosa.

Ovvero, se voglio misurare le performance di come un for, un foreach, un while/list/each e un while/current/next si comportano su una lista di 1000 elementi, senza quindi eseguire nessuna operazione all'interno, allora il codice deve acquisire subito prima del ciclo che esegue le N iterazioni sul sistema che sta per essere testato l'orario corrente, con relativi millisecondi, e poi questo deve essere riacquisito subito dopo il termine per poter calcolare il tempo impiegato complessivamente e va quindi calcolato il tempo medio di una operazione dividendo il tempo totale dello specifico metodo per le N iterazioni.

Come per il calcolo del tempo impiegato, anche i test sulla memoria dovranno essere eseguiti tutti nello stesso modo: subito prima e subito dopo i cicli va acquista la memoria utilizzata in quel dato momento

NOTA: se state usando windows è necessario che la versione di php sia la 5.2.1 o superiore mentre se state usando linux o avete, come per windows, una versione uguale o superiore alla 5.2.1 oppure la vostra versione di php deve essere stata compilata con --enable-memory-limit, cosa che potete scoprire lanciando la funzione phpinfo()

NOTA: secondo php non viene usata memoria nel codice di d'esempio che ho scritto per i test sulla e memoria, e non capisco se è dovuto a una super miracolosa ottimizzazione nel core di php o ad un calcolo strano, motivo per il quale per il momento non postate test per verificare le quantità di memoria usate dai vari codici perché devo verificare se con le versioni precedenti o meno c'è questa stessa anomalia

Il primo post del thread sarà un mio codice di test di esempio, che metterà a confronto questi quattro sistemi e, quando verranno postati i sistemi di confronto, dovrà essere seguito lo stesso schema, in modo da permettere una facile conversione a posteriori.

I premi, come in un qualsiasi contest, ci sono anche qua, anche se comunque vincono tutti: nel database, quando verrà creato, saranno inseriti i vostri nick/nomi e il link al vostro sito web in modo da visualizzare queste informazioni quando verrà visualizzato il test

La seconda fase, una volta terminato il contest, sarà quella di raccogliere tutto questo codice, convertirlo come già detto in unità di test, ed inserirlo in un database. Inoltre verrà creata una piccola piattaforma di testing che permetterà a chi vuole di eseguire tutti questi test sul priprio sistema per contribuire alla raccolta delle performance specifiche per configurazione, hardware e software.

Per postare dovete seguire questo struttura, che verrà ovviamente riportata anche nel primo test

Ovviamente, nel thread, oltre a postare il codice, potete postare, anzi dovete postare, suggerimenti, correzioni, aggiunte o quant'altro che possare sfruttare al meglio le informazioni che verranno raccolte

Ultima cosa, prima che me ne dimentico, i test dovranno funzionare con una versione la versione 5 o superiore di php, dato che la 4 va lentamente scomparendo

[ B ]AUTORE[ /B ]
nome o nomi degli autori del codice su più righe (non inserite per piacere link al proprio sito web dato che potrebbe essere inteso come spam, gli indirizzo dei propri siti web verranno raccolti al momento della creazione del database)

[ B ]DESCRIZIONE[ /B ]
In questo campo va inserita una dettagliata descrizione

[ B ]CATEGORIA[ /B ]
Una possibile categoria da utilizzare nel database quando questo verrà messo in piedi, non è detto che sia quella, anzi, però può servire come spunto per quando si creeranno le categorie per le ricerche online.
Ovviamente è possibile specificare più categorie, o categorie con sotto categorie separandole con uno slash, simile ad un url web quindi

[ B ]DIPENDENZE[ /B ]
Eventuali dipendenze come estensioni o file php esterni, con relativo link per il download, se questi sono necessari allo scopo del vostro test

[ B ]CODICE[ /B ]
[ PHP ]
- il codice va TASSATIVAMENTE inserito all'interno del tag PHP, deve essere indentato, commentato e facilmente leggibile!
- Il codice non deve essere complesso e all'interno dei cicli deve starci il minimo codice necessario!
- Le verifiche devono essere eseguite non su una singola iterazione ma su un numero elevato di iterazioni, come nell'esempio di sotto. Minimo mille iterazioni
- Lo stile del codice deve essere lo stesso, seguite quello postato nel mio post d'esempio
[ /PHP ]

Come potete vedere, dentro il quote ci sta il modellino da utilizzare, e i TAG del forum sono stati inseriti con gli spazi tra le quadre in modo da permettere un semplice copia/incolla

qui c'è ne sta un modello senza i miei commenti

[ B ]AUTORE[ /B ]

[ B ]DESCRIZIONE[ /B ]

[ B ]CATEGORIA[ /B ]

[ B ]DIPENDENZE[ /B ]

[ B ]CODICE[ /B ]
[ PHP ]

[ /PHP ]

Per concludere: come vedrete nel mio primo post il codice deve essere eseguito, includendo dopo le definizioni del test e dopo la classe, un require_once al codice che effettivamente lancerà il test.

Qui c'è il file, che ho chiamato TimeUnitTesting.php:

<?php

// Elimina la durata massima della pagina
set_time_limit(0);

// Acquisisce l'orario di inizio del test
$startTotalTestDuration = microtime(true);

// Cicla i metodi
foreach($methods as $method => $description)
{
    // Stampa delle informazioni a video
    echo "[B]{$method}[/B]: {$description}
\r\n";
    echo "
\r\n";
    flush();

    // Acquisisce la durata del test
    $testDuration = call_user_func_array(array($class, $method), array($iterations, $dataToTest));

    // Stampa le informazioni acquisite
    echo 'Durata totale del test: [B]' . sprintf('%0.20f', $testDuration) . "[/B]
\r\n";
    echo 'Durata media di una singola operazione nel test: [B]' . sprintf('%0.20f', ($testDuration / $iterations)) . "[/B]
\r\n";

    // Separa il test dal successivo
    echo "
\r\n";
    echo "
\r\n";
}

echo "TEST ESEGUITO CORRETTAMENTE!
\r\n";
echo 'Il test &egrave; durato: [B]' . sprintf('%0.20f', microtime(true) - $startTotalTestDuration) . '[/B] secondi';

?>

NOTA: non includete output o risultati please

[daniele_dll]

AUTORE
daniele_dll

DESCRIZIONE
Test per confrontare le performance dei principali metodi per gestire i cicli sulle liste. Il test mette a confronto il For, il Foreach e poi due strutture un po più complesse come il While/List/Each e il While/Current/Next.

CATEGORIA
PERFORMANCE/LOOPS

DIPENDENZE

CODICE

<?php

/**
 * Per prima cosa va definito il nome della classe da testare e l'elenco de
 * metodi da testare, in modo da permettere al codice presente dopo la classe
 * di automatizzare le operazioni di testing.
 * L'elenco dei metodi è composto da una lista Chiave/Valore dove la chiave
 * corrisponde al nome del metodo mentre il valore alla sua descrizione
 * Inoltre va anche definito il numero di iterazioni da eseguire
 */
$class = 'LoopsValuesInAListTimeUnitTest';
$iterations = 10000;
$methods = array
(
    'TestForEach'               => 'Test di Foreach',
    'TestFor'                   => 'Test di For',
    'TestWhileListEach'         => 'Test di While/List/Each',
    'TestWhileCurrentNext'      => 'Test di While/Current/Next'
);



/**
 * Qui va costruito il dato da utilizzare nei test, in questo caso un array
 * lungo diecimila elementi numerici corrispondenti al numero dell'elemento
 * senza chiave, quindi un normale array di elementi
 */
$dataToTest = array();
for($index = 0; $index < 1000; $index++)
{
    $dataToTest[] = $index;
}



/**
 * Qui è presente la classe che contiene il codice per il testing. I metodi
 * statici devono sempre contenere due elementi:
 * - Le iterazioni, ovvero il numero di cicli da eseguire per test
 * - I dati da testare
 *
 * Quest'ultima variabile deve essere SEMPRE presente, ovviamente non ha
 * importanza il tipo e se non vi serve dichiaratela come NULL
 */
class LoopsValuesInAListTimeUnitTest
{
    public static function TestForeach($Iterations, $DataToTest)
    {
        // Inizializza le variabili
        $duration = 0;

        // Avvia le iterazioni
        for($iteration = 0; $iteration < $Iterations; $iteration++)
        {
            // Acquisice l'orario dell'inizio del test
            $startTime = microtime(true);

            // Avvia il ciclo
            foreach($DataToTest as $value)
            {
            }

            // Acquisice la durata
            $duration += microtime(true) - $startTime;
        }

        // Restituisce la durata
        return $duration;
    }

    public static function TestFor($Iterations, $DataToTest)
    {
        // Inizializza le variabili
        $duration = 0;

        // Conta gli elementi (Questo va eseguito prima del conteggio)
        $dataToTestLenght = count($DataToTest);

        // Avvia le iterazioni
        for($iteration = 0; $iteration < $Iterations; $iteration++)
        {
            // Acquisice l'orario dell'inizio del test
            $startTime = microtime(true);

            // Avvia il ciclo
            for($index = 0; $index < $dataToTestLenght; $index++)
            {
            }

            // Acquisice la durata
            $duration += microtime(true) - $startTime;
        }

        // Restituisce la durata
        return $duration;
    }

    public static function TestWhileListEach($Iterations, $DataToTest)
    {
        // Inizializza le variabili
        $duration = 0;

        // Resetta l'array
        reset($DataToTest);

        // Avvia le iterazioni
        for($iteration = 0; $iteration < $Iterations; $iteration++)
        {
            // Acquisice l'orario dell'inizio del test
            $startTime = microtime(true);

            // Avvia il ciclo
            while(list($key, $value) = each($DataToTest))
            {
            }

            /**
             * In questo caso va conteggiato il tempo della funzione reset
             * sull'array perché è un'operazione che in un ambiente reale
             * verrebbe sempre e comunque eseguita
             */
            reset($DataToTest);

            // Acquisice la durata
            $duration += microtime(true) - $startTime;
        }

        // Restituisce la durata
        return $duration;
    }

    public static function TestWhileCurrentNext($Iterations, $DataToTest)
    {
        // Inizializza le variabili
        $duration = 0;

        // Resetta l'array
        reset($DataToTest);

        // Avvia le iterazioni
        for($iteration = 0; $iteration < $Iterations; $iteration++)
        {
            // Acquisice l'orario dell'inizio del test
            $startTime = microtime(true);

            // Avvia il ciclo
            while(($value = current($DataToTest)) !== false)
            {
                // Si sposta all'elemento successivo
                next($DataToTest);
            }

            /**
             * In questo caso va conteggiato il tempo della funzione reset
             * sull'array perché è un'operazione che in un ambiente reale
             * verrebbe sempre e comunque eseguita
             */
            reset($DataToTest);

            // Acquisice la durata
            $duration += microtime(true) - $startTime;
        }

        // Restituisce la durata
        return $duration;
    }
}

// Include il codice per il test
require_once('TimeUnitTesting.php');

?>

[andr3a]

[edit]
mi dicono dalla regia che se rileggo capisco ... in caso torno a commentare

[andr3a]

AUTORE
andr3a

DESCRIZIONE
Test per confrontare le performance dei principali metodi per svolgere operazioni a seconda di determinate condizioni.

CATEGORIA
PERFORMANCE/CHECKS

DIPENDENZE

CODICE

<?php
$class = 'IfElifElseSwitchTernaryTimeUnitTest';
$iterations = 10000;
$methods = array
(
    'TestIfElifElse'    => 'Test if elseif and else',
    'TestSwitch'        => 'Test switch',
    'TestTernary'        => 'Test double ternary operator'
);
$dataToTest = array();
for($index = 0; $index < $iterations; $index++)
    $dataToTest[] = $index;
class IfElifElseSwitchTernaryTimeUnitTest
{
    public static function TestIfElifElse($Iterations, $DataToTest)
    {
        $duration = 0;
        for($iteration = 0; $iteration < $Iterations; $iteration++)
        {
            $startTime = microtime(true);
            if($DataToTest[$iteration] == null)
                $DataToTest[$iteration] = null;
            elseif($DataToTest[$iteration] == false)
                $DataToTest[$iteration] = false;
            else
                $DataToTest[$iteration] = true;
            $duration += microtime(true) - $startTime;
        }
        return $duration;
    }
    public static function TestSwitch($Iterations, $DataToTest)
    {
        $duration = 0;
        for($iteration = 0; $iteration < $Iterations; $iteration++)
        {
            $startTime = microtime(true);
            switch($DataToTest[$iteration]) {
                case    null:
                    $DataToTest[$iteration] = null;
                    break;
                case    false:
                    $DataToTest[$iteration] = false;
                    break;
                default:
                    $DataToTest[$iteration] = true;
                    break;
            }
            $duration += microtime(true) - $startTime;
        }
        return $duration;
    }
    public static function TestTernary($Iterations, $DataToTest)
    {
        $duration = 0;
        for($iteration = 0; $iteration < $Iterations; $iteration++)
        {
            $startTime = microtime(true);
            $DataToTest[$iteration] = $DataToTest[$iteration] == null ? null : $DataToTest[$iteration] == false ? false : true;
            $duration += microtime(true) - $startTime;
        }
        return $duration;
    }
}
require_once('TimeUnitTesting.php');
?>

[andr3a]

AUTORE
andr3a

DESCRIZIONE
Test per confrontare le performance dei vari metodi possibili per richiamare un metodo di un'istanza di classe.

CATEGORIA
PERFORMANCE/CLASSES

DIPENDENZE

CODICE

<?php
$class = 'DirectEvalCallStringFuncTimeUnitTest';
$iterations = 100000;
$methods = array
(
    'TestDirect'    => 'Test direct method call',
    'TestEval'    => 'Test method using evaluation',
    'TestCall'    => 'Test magic __call method',
    'TestString'    => 'Test automatic string evaluation',
    'TestFunc'    => 'Test call_user_func core function'
);

class DataToTest {

    public function __call($method, $arguments){
        return $this->callMe();
    }

    public function callMe(){
        return;
    }
}

$dataToTest = new DataToTest;



class DirectEvalCallStringFuncTimeUnitTest
{
    public static function TestDirect($Iterations, $DataToTest)
    {
        $duration = 0;
        for($iteration = 0; $iteration < $Iterations; $iteration++)
        {
            $startTime = microtime(true);
            $DataToTest->callMe();
            $duration += microtime(true) - $startTime;
        }
        return $duration;
    }
    public static function TestEval($Iterations, $DataToTest)
    {
        $duration = 0;
        for($iteration = 0; $iteration < $Iterations; $iteration++)
        {
            $startTime = microtime(true);
            eval('$DataToTest->callMe();');
            $duration += microtime(true) - $startTime;
        }
        return $duration;
    }
    public static function TestCall($Iterations, $DataToTest)
    {
        $duration = 0;
        for($iteration = 0; $iteration < $Iterations; $iteration++)
        {
            $startTime = microtime(true);
            $DataToTest->callYou();
            $duration += microtime(true) - $startTime;
        }
        return $duration;
    }
    public static function TestString($Iterations, $DataToTest)
    {
        $duration = 0;
        $method = 'callMe';
        for($iteration = 0; $iteration < $Iterations; $iteration++)
        {
            $startTime = microtime(true);
            $DataToTest->$method();
            $duration += microtime(true) - $startTime;
        }
        return $duration;
    }
    public static function TestFunc($Iterations, $DataToTest)
    {
        $duration = 0;
        for($iteration = 0; $iteration < $Iterations; $iteration++)
        {
            $startTime = microtime(true);
            call_user_func(array(&$DataToTest, 'callMe'));
            $duration += microtime(true) - $startTime;
        }
        return $duration;
    }
}
require_once('TimeUnitTesting.php');
?>

[daniele_dll]

[UP]

[daniele_dll]

dato che non interessa più di tanto questo è l'ultimo up che faccio

[andr3a]

AUTORE
andr3a

DESCRIZIONE
Test per confrontare le performance tra la serializzazione e deserializzazione in PHP e la JavaScript Object Notation.
Notare che il confronto mostra come la serializzazione rappresenti realmente la variabile in esame che una volta deserializzata sarà identica all'originale a differenza di JSON che perde di informazioni utili per il PHP in encoding e quindi anche in decoding, a favore di una velocità decisamente superiore e di una compatibilità esterna maggiore.

CATEGORIA
PERFORMANCE/SERIALIZZATION

DIPENDENZE
libreria json della PECL o PHP >= 5.2 con la stessa abilitata

CODICE

<?php
$class = 'SerializeJson';
$iterations = 1000;
$methods = array
(
    'serialize'        => 'Test serialize function',
    'unserialize'        => 'Test unserialize function',
    'json_encode'        => 'Test json encoder',
    'json_decode'        => 'Test json decoder'
);

$dataToTest = array(
    'code' => array(),
    'seri' => array(),
    'json' => array()
);
for($index = 0; $index < 200; $index++)
    $dataToTest['code'] = array(new SerializeJson, 1, true, 2.3, 'a'.chr(7).'b', null, $dataToTest['code']);
$dataToTest['seri'] = serialize($dataToTest['code']);
$dataToTest['json'] = json_encode($dataToTest['code']);    

class SerializeJson
{
    public static function serialize($Iterations, $DataToTest)
    {
        for($duration = 0, $iteration = 0; $iteration < $Iterations; $iteration++)
        {
            $startTime = microtime(true);
            $tmp = serialize($DataToTest['code']);
            $duration += microtime(true) - $startTime;
        }
        return $duration;
    }
    public static function unserialize($Iterations, $DataToTest)
    {
        for($duration = 0, $iteration = 0; $iteration < $Iterations; $iteration++)
        {
            $startTime = microtime(true);
            $tmp = unserialize($DataToTest['seri']);
            $duration += microtime(true) - $startTime;
        }
        return $duration;
    }
    public static function json_encode($Iterations, $DataToTest)
    {
        for($duration = 0, $iteration = 0; $iteration < $Iterations; $iteration++)
        {
            $startTime = microtime(true);
            $tmp = json_encode($DataToTest['code']);
            $duration += microtime(true) - $startTime;
        }
        return $duration;
    }
    public static function json_decode($Iterations, $DataToTest)
    {
        for($duration = 0, $iteration = 0; $iteration < $Iterations; $iteration++)
        {
            $startTime = microtime(true);
            $tmp = json_decode($DataToTest['json']);
            $duration += microtime(true) - $startTime;
        }
        return $duration;
    }
}
require_once('TimeUnitTesting.php');
?>

[andr3a]

AUTORE
andr3a

DESCRIZIONE
Test per confrontare le performance i vari metodi più o meno usati per prendere il solo valore da un array popolato in sequenza NON casuale (ed ovviamente prendendo il valore o modificandolo, come fossero veri loops)

CATEGORIA
PERFORMANCE/LOOP

CODICE

<?php
$class = 'ForEachWhileFor';
$iterations = 1000;
$methods = array
(
    '_whileEach'          => 'Test while(list() = each())',
    '_for'                => 'Test for',
    '_forCount'           => 'Test for using count',
    '_forEach'            => 'Test foreach'
);

$dataToTest = array();
for($index = 0; $index < 1000; $index++)
    $dataToTest[] = uniqid(rand(), true);   

class ForEachWhileFor
{
    public static function _whileEach($Iterations, $DataToTest)
    {
        for($duration = 0, $iteration = 0; $iteration < $Iterations; $iteration++)
        {
            $startTime = microtime(true);
            while(list(, $value) = each($DataToTest))$value = ' '.$value;
        reset($DataToTest);
            $duration += microtime(true) - $startTime;
        }
        return $duration;
    }
    public static function _for($Iterations, $DataToTest)
    {
        for($duration = 0, $iteration = 0; $iteration < $Iterations; $iteration++)
        {
            $startTime = microtime(true);
            for($i = 0, $length = count($DataToTest); $i < $length; $i++)$value = ' '.$DataToTest[$i];
            $duration += microtime(true) - $startTime;
        }
        return $duration;
    }
    public static function _forCount($Iterations, $DataToTest)
    {
        for($duration = 0, $iteration = 0; $iteration < $Iterations; $iteration++)
        {
            $startTime = microtime(true);
            for($i = 0; $i < count($DataToTest); $i++)$value = ' '.$DataToTest[$i];
            $duration += microtime(true) - $startTime;
        }
        return $duration;
    }
    public static function _forEach($Iterations, $DataToTest)
    {
        for($duration = 0, $iteration = 0; $iteration < $Iterations; $iteration++)
        {
            $startTime = microtime(true);
        foreach($DataToTest as $value)$value = ' '.$value;
            $duration += microtime(true) - $startTime;
        }
        return $duration;
    }
}
require_once('TimeUnitTesting.php');
?>