PHP Sebességteszt

500.000 byteos string végig pörgetése FOR/WHILE/FOREACH ciklusokkal, mivel a FOREACH nem tud a stringen végig menni, ezért neki átalakítjuk tömbbé a stringet. A mérésekből ezt a string->array konverziót kihagytam.

Miután a foreach kiemelkedő sebességet nyújt, érdemes kipróbálni, hogy a for és while mit produkál ebben a helyzetben. Bár sejthető, hiszen erre már volt példa (Felsorolás alapú ciklusok terheléses tesztje)

Iterációk száma: 500.000

    // $tmp - 500.000byte string, előre feltöltve
    $size = strlen($tmp);
    for ($i=0; $i<$size; $i++){
        $x = $tmp[$i];
    }

    // $tmp - 500.000byte string, előre feltöltve
    $pos = 0;
    while(null != ($x = $tmp[$pos++])){
    }

    // $tmp - 500.000byte string, előre feltöltve
    // $tmp_a-t előre feltöltjük így tömböt kapunk: $tmp_a = str_split($tmp); 
    foreach($tmp_a as $x){
    }

    // $tmp - 500.000byte string, előre feltöltve
    // $tmp_a-t előre feltöltjük így tömböt kapunk: $tmp_a = str_split($tmp); 
    $pos = 0;
    while(null != ($x = $tmp_a[$pos++])){
    }

    // $tmp - 500.000byte string, előre feltöltve
    // $tmp_a-t előre feltöltjük így tömböt kapunk: $tmp_a = str_split($tmp); 
    $size = count($tmp_a);
    for ($i=0; $i<$size; $i++){
        $x = $tmp_a[$i];
    }

Konklúzió:

Egyértelműen látszik, hogy a foreach nyert, viszont figyelembe kell venni, hogy ott már tömbként van kezelve a string, vagyis nem szabad megfeledkezni az átalakítási időről! Illetve ha lehetőségünk van rá, ekkora (vagy nagyobb) iteráció számnál eleve tömbként tároljuk az adatot.

Ha szigorúan a string iterációt vesszük, akkor a for ciklus hoz nekünk pár µs-t.

Az elágazások a programozás során elengedhetetlen kellékek, ezért rögtön velük kezdjük

Iterációk száma: 1000

$answer = 2;
$iteration = 1000;
while($i < $iteration) {

        if($answer == 1) {

        } else if($answer == 2) {

        }

        ++$i;
    }

$answer = 2;
$iteration = 1000;
while($i < $iteration) {

    if($answer == 1) {

    } else if($answer == 3) {

    } else {

    }

    ++$i;
}

$answer = 2;
$iteration = 1000;
while($i < $iteration) {

    if($answer === 1) {

    } else if($answer === 2) {

    }

    ++$i;
}

$answer = 2;
$iteration = 1000;
while($i < $iteration) {

    if($answer === 1) {

    } else if($answer === 3) {

    } else {

    }

    ++$i;
}

$answer = 2;
$iteration = 1000;
while($i < $iteration) {

    switch($answer) {

        case 1:

            break;

        case 2:

            break;
    }

    ++$i;
}

$answer = 2;
$iteration = 1000;
while($i < $iteration) {

    switch($answer) {

        case 1:

            break;

        case 3:

            break;

        default:

            break;
    }

    ++$i;
}

$answer = 2;
$iteration = 1000;
while($i < $iteration) {

    if($answer == 1) {
        $x = 1;
    } else {
        $x = 2;
    }

    ++$i;
}

$answer = 2;
$iteration = 1000;
while($i < $iteration) {
    $x = ($answer==1)?1:2;
    ++$i;
}

Konklúzió:

Egy-két ezer iterációnál mindegy, hogy switch-case vagy if-else vezérlést valósítunk meg, azonban egyenlőség vizsgálatnál a (=== típusazonos összehasonlító operátor) jelentősebb sebesség növekedést mutat a (== összehasonlító operátor)-hez képest!

Érdekesség, hogy a kedvelt (már akinél) egysoros if (utolsó 2 teszt) átlag 6-7%-kal lassabb volt a normál if-else szerkezetnél.

A sima for() és while() ciklusokat hasonlítja egymáshoz, terhelés nélkül.

Iterációk száma: 1000000

    for($i = 0; $i < 1000000; ++$i);

    $i = 0; while($i < 1000000) ++$i;

	$iteration = 1000000;
    for($i = $iteration; $i > 0; --$i);

	$iteration = 1000000;
    for($i = $iteration; $i; --$i);

	$iteration = 1000000;
    for($i = $iteration; --$i; );

    $i = 1000000; while($i > 0) --$i;

    $i = 1000000; while($i) --$i;

    $i = 1000000; while(--$i);

Konklúzió:

Szinte minden alkalommal a while() volt a gyorsabb.

Frissítés (2013-01-23):

Egy érdekes és szerintem hasznos teszt típussal bővítettem a for/while ciklusokat. Mégpedig a vissza felé számlálás, itt két megoldás van a ciklusok feltételénél, vagy "$i > 0" (amíg nagyobb mint 0), vagy simán "$i" a feltétel (amíg true). Míg a Javascriptben az látszik, hogy a relációval vizsgált ciklusok gyorsabbak, addig a PHP-ban pont fordított az eredmény, a FOR és a WHILE is akkor volt a leggyorsabb, mikor true/false vizsgálatot végeztünk.

Ami szintén nem elhanyagolható, hogy a true/false vizsgálat A és B verziót kapott, a B a lehető legtömörebb kód, elvileg egy optimalizált verziója A-nak. Viszont a B verziók rendre lassabbak voltak az A-nál!

A ciklusokban rengeteg időt spórolhatunk, ha lehetőség szerint előre kiszámítjuk egy ciklus várható iterációinak számát!

Iterációk száma: 1000

    $i   = 0; $tmp = '';
    while($i < 10000) {
      $tmp .= 'a';
      ++$i;
    }
    $x = array_fill(5, 1000, $tmp);
    unset($i, $tmp);

    $size = count($x);
    for ($i=0; $i < $size; $i++);

    $i   = 0; $tmp = '';
    while($i < 10000) {
      $tmp .= 'a';
      ++$i;
    }
    $x = array_fill(5, 1000, $tmp);
    unset($i, $tmp);

    for ($i=0; $i < count($x); $i++);

    $i   = 0; $tmp = '';
    while($i < 10000) {
      $tmp .= 'a';
      ++$i;
    }
    $x = array_fill(5, 1000, $tmp);
    unset($i, $tmp);

    $size = sizeof($x);
    for ($i=0; $i  < $size; $i++);

    $i   = 0; $tmp = '';
    while($i < 10000) {
      $tmp .= 'a';
      ++$i;
    }
    $x = array_fill(5, 1000, $tmp);
    unset($i, $tmp);

    for ($i=0; $i < sizeof($x); $i++);

Konklúzió:

A count() és sizeof() között nincs lényegi különbség, viszont az eredmény abszolút magáért beszél.

Ha előre kiszámítjuk a hurkok számát, akkor rengeteg időt nyerünk, természetesen azért mert ha a for ciklusba ágyazzuk a count() vagy sizeof()-t, akkor minden egyes iterációban kiszámolja a (már előre úgy is tudott) eredményt!

Keressük meg melyik megoldás a leghatékonyabb egy hash tömböt végig pörgetni.
foreach() vs. for() vs. while(list() = each())

A teszthez egy 100 elemű, bejegyzései 24byte-os kulcsot és 10k-nyi adatot tartalmaznak.

    $i   = 0;
    $tmp = '';
    while($i < 10000) {
      $tmp .= 'a';
      ++$i;
    }
    $aHash = array_fill(100000000000000000000000, 100, $tmp);
    unset($i, $tmp);

    reset($aHash);
    foreach($aHash as $val);

    $i   = 0;
    $tmp = '';
    while($i < 10000) {
      $tmp .= 'a';
      ++$i;
    }
    $aHash = array_fill(100000000000000000000000, 100, $tmp);
    unset($i, $tmp);

    reset($aHash);
    while(list(,$val) = each($aHash));

    $i   = 0;
    $tmp = '';
    while($i < 10000) {
      $tmp .= 'a';
      ++$i;
    }
    $aHash = array_fill(100000000000000000000000, 100, $tmp);
    unset($i, $tmp);

    reset($aHash);
    foreach($aHash as $key => $val);

    $i   = 0;
    $tmp = '';
    while($i < 10000) {
      $tmp .= 'a';
      ++$i;
    }
    $aHash = array_fill(100000000000000000000000, 100, $tmp);
    unset($i, $tmp);

    reset($aHash);
    while(list($key,$val) = each($aHash));

    $i   = 0;
    $tmp = '';
    while($i < 10000) {
      $tmp .= 'a';
      ++$i;
    }
    $aHash = array_fill(100000000000000000000000, 100, $tmp);
    unset($i, $tmp);

    reset($aHash);
    foreach($aHash as $key=>$val) $tmp[] = $aHash[$key];

    $i   = 0;
    $tmp = '';
    while($i < 10000) {
      $tmp .= 'a';
      ++$i;
    }
    $aHash = array_fill(100000000000000000000000, 100, $tmp);
    unset($i, $tmp);

    reset($aHash);
    while(list($key) = each($aHash)) $tmp[] = $aHash[$key];

    $i   = 0;
    $tmp = '';
    while($i < 10000) {
      $tmp .= 'a';
      ++$i;
    }
    $aHash = array_fill(100000000000000000000000, 100, $tmp);
    unset($i, $tmp);

    reset($aHash);
    foreach($aHash as $key[] => $val[]);

    $i   = 0;
    $tmp = '';
    while($i < 10000) {
      $tmp .= 'a';
      ++$i;
    }
    $aHash = array_fill(100000000000000000000000, 100, $tmp);
    unset($i, $tmp);

    reset($aHash);
    array_keys($aHash);
    array_values($aHash);

    $i   = 0;
    $tmp = '';
    while($i < 10000) {
      $tmp .= 'a';
      ++$i;
    }
    $aHash = array_fill(100000000000000000000000, 100, $tmp);
    unset($i, $tmp);

    reset($aHash);
    $key = array_keys($aHash);
    $size = sizeOf($key);
    for ($i=0; $i < $size; $i++) $tmp[] = $aHash[$key[$i]];

Konklúzió:

Minden esetben kitűnik, hogy a foreach() jóval gyorsabb, mind a while(), mind a for() ciklusoknál.

Ez a teszt szintén egy hash tömbön fut végig, de közben módosítást is végez rajta.
foreach() vs. for() vs. while()

A teszthez egy 100 elemű, bejegyzései 24byte-os kulcsot és 10k-nyi adatot tartalmaznak.

    $i   = 0;
    $tmp = '';
    while($i < 10000) {
      $tmp .= 'a';
      ++$i;
    }
    $aHash = array_fill(100000000000000000000000, 100, $tmp);
    unset($i, $tmp);

    reset($aHash);
    foreach($aHash as $key=>$val) $aHash[$key] .= "a";

    $i   = 0;
    $tmp = '';
    while($i < 10000) {
      $tmp .= 'a';
      ++$i;
    }
    $aHash = array_fill(100000000000000000000000, 100, $tmp);
    unset($i, $tmp);

    reset($aHash);
    while(list($key) = each($aHash)) $aHash[$key] .= "a";

    $i   = 0;
    $tmp = '';
    while($i < 10000) {
      $tmp .= 'a';
      ++$i;
    }
    $aHash = array_fill(100000000000000000000000, 100, $tmp);
    unset($i, $tmp);

    $key = array_keys($aHash);
    $size = sizeOf($key);
    for ($i=0; $i<$size; $i++) $aHash[$key[$i]] .= "a";

Konklúzió:

A foreach() és for() render egymás mellett végeztek, de 10ből 9-szer a foreach() picit jobb volt. A while() láthatóan, rendre lemaradt átlag 35%-kal.

Az echo és a print tesztje, sima stringekkel, összefűzve változóval...

Iterációk száma: 1000

    while($i < 1000) {
        echo 'HelloHelloHelloHelloHelloHello';
        ++$i;
    }

    while($i < 1000) {
        print 'HelloHelloHelloHelloHelloHello';
        ++$i;
    }

    while($i < 1000) {
        echo 'Hello'.'Hello'.'Hello'.'Hello'.'Hello'.'Hello';
        ++$i;
    }

    while($i < 1000) {
        echo 'Hello','Hello','Hello','Hello','Hello','Hello';
        ++$i;
    }

    while($i < 1000) {
        print 'Hello'.'Hello'.'Hello'.'Hello'.'Hello'.'Hello';
        ++$i;
    }

    while($i < 1000) {
        echo 'Hello'.$a.'Hello'.$a.'Hello'.$a;
        ++$i;
    }

    while($i < 1000) {
        echo 'Hello',$a,'Hello',$a,'Hello',$a;
        ++$i;
    }

    while($i < 1000) {
        print 'Hello'.$a.'Hello'.$a.'Hello'.$a;
        ++$i;
    }

Konklúzió:

Az üres string kiírást mellőztem a tesztből mert elég kevés a gyakorlati haszna. Az echo a printnél alapból úgy 10%-kal jobban teljesített, azon kívűl látható, hogy a string összefűzésnél ('xx'.'xx') gyorsabb (nagyszámú iterációnál), ha a nem string összefűzést csinálunk, hanem az echo-t hívjuk meg egymás után többször ('xx','xx').

Valamint nem érdemes az előre ismert egybefüggő ('aaaa') szövegeket ('aa'.'aa') egyesíteni, hiszen jóval lassabb futást eredményez.

Ha változókkal is vegyítjük a kimenetet, akkor is jól látható, hogy az echo a jobb választás, még pedig a többszörös meghívással ('xx',$x)

isSet() vagy empty(), valamint is_array()

Iterációk száma: 1000

    $isset       = true;
    $array       = array();
    $string      = '';
    
    while($i < 1000) {
        isSet($isset);
        ++$i;
    }

    $isset       = true;
    $array       = array();
    $string      = '';
    
    while($i < 1000) {
        empty($isset);
        ++$i;
    }

    $isset       = true;
    $array       = array();
    $string      = '';

    while($i < 1000) {
        isset($notset);
        ++$i;
    }

    $isset       = true;
    $array       = array();
    $string      = '';

    while($i < 1000) {
        empty($notset);
        ++$i;
    }

    $isset       = true;
    $array       = array();
    $string      = '';

    while($i < 1000) {
        isset($array);
        ++$i;
    }

    $isset       = true;
    $array       = array();
    $string      = '';

    while($i < 1000) {
        empty($array);
        ++$i;
    }

    $isset       = true;
    $array       = array();
    $string      = '';

    while($i < 1000) {
        is_array($array);
        ++$i;
    }

    $isset       = true;
    $array       = array();
    $string      = '';

    while($i < 1000) {
        is_array($string);
        ++$i;
    }

    $isset       = true;
    $array       = array();
    $string      = '';

    while($i < 1000) {
        is_array($notset);
        ++$i;
    }

    $isset       = true;
    $array       = array();
    $string      = '';

    while($i < 1000) {
        if (isset($notset) && is_array($notset)){;}
        ++$i;
    }

    $isset       = true;
    $array       = array();
    $string      = '';

    while($i < 1000) {
        if (isset($array) && is_array($array)){;}
        ++$i;
    }

Konklúzió:

Az isset() és az empty() is fej-fej mellett teljesít, mind létező mind nem létező változónál.

Az is_array()-nál viszont jelentős sebességbeli kilengések tapasztalhatóak a változó típusától függően, valamint ha nincs beállított változó akkor jelentősen lassul az is_array()!

Az is_array()-t nagyon is érdemes az isset()-tel együtt használni egy feltételben (lásd utolsó 2 teszt), mert egy if-n belül ha az isset()-nél megbukott a feltétel, akkor nem folytatja a php vizsgálatot, így jelentős gyorsulás érhető el ha nem volt a változó beállítva! (Ellenben egy csekély lassulás betudható a plusz vizsgálatnak)

Tömbök elérésének összehasonlítása érték és referencia alapon.

Iterációk száma: 1000

//feltöltés
for($i=0; $i < 1000;$i++)
    $array[$i] = 'HelloHello';
//mérés
$t = microtime(true);

for($i = 0; $i < 1000; $i++)
    $x = $array[$i];
    
return (microtime(true) - $t)* 1000000;

//feltöltés
for($i=0; $i < 1000;$i++)
    $array[$i] = 'HelloHello';
//mérés
$t = microtime(true);

for($i = 0; $i < 1000; $i++)
    $x = &$array[$i];

return (microtime(true) - $t) * 1000000;

//feltöltés
for($i=0; $i < 1000;$i++)
    for($ii=0; $ii < 10;$ii++)
        $array2[$i][$ii] = 'HelloHello';
//mérés
$t = microtime(true);

for($i = 0; $i < 1000; $i++)
    $x = $array2[$i][0];
    
return (microtime(true) - $t)*1000000;

//feltöltés
for($i=0; $i < 1000;$i++)
    for($ii=0; $ii < 10;$ii++)
        $array2[$i][$ii] = 'HelloHello';
//mérés
$t = microtime(true);

for($i = 0; $i < 1000; $i++)
    $x = &$array2[$i][0];

return (microtime(true) - $t) * 1000000;

//feltöltés
for($i=0; $i < 1000;$i++)
    for($ii=0; $ii < 7;$ii++)
        for($iii=0; $iii < 7;$iii++)
            for($iiii=0; $iiii < 7;$iiii++)
                $array4[$i][$ii][$iii][$iiii] = 'HelloHello';
//mérés
$t = microtime(true);

for($i = 0; $i < 1000; $i++)
    $x = $array4[$i][1][2][3];
    
return (microtime(true) - $t)*1000000;

//feltöltés
for($i=0; $i < 1000;$i++)
    for($ii=0; $ii < 7;$ii++)
        for($iii=0; $iii < 7;$iii++)
            for($iiii=0; $iiii < 7;$iiii++)
                $array4[$i][$ii][$iii][$iiii] = 'HelloHello';
//mérés
$t = microtime(true);

for($i = 0; $i < 1000; $i++)
    $x = &$array4[$i][1][2][3];

return (microtime(true) - $t) * 1000000;

//feltöltés
for($i=0; $i < 1000;$i++)
    $array8[$i]['H']['He']['Hel']['Hell']['Hello']['HelloH']['HelloHe'] = 'HelloHello';
//mérés
$t = microtime(true);

for($i = 0; $i < 1000; $i++)
    $x = $array8[$i]['H']['He']['Hel']['Hell']['Hello']['HelloH']['HelloHe'];
    
return (microtime(true) - $t)*1000000;

//feltöltés
for($i=0; $i < 1000;$i++)
    $array8[$i]['H']['He']['Hel']['Hell']['Hello']['HelloH']['HelloHe'] = 'HelloHello';
//mérés
$t = microtime(true);

for($i = 0; $i < 1000; $i++)
    $x = &$array8[$i]['H']['He']['Hel']['Hell']['Hello']['HelloH']['HelloHe'];

return (microtime(true) - $t) * 1000000;

Konklúzió:

Közel egyforma értékeket produkált mind az érték, mind a referenciakénti tömb lekérdezés, illetve az asszociatív címzésnél a referenciakénti átadás elkezdett lassulni. Azonban ne feledjük, hogy a referencia szerinti paraméterátadás nagyobb objektumok, tömbök esetén jelentősen gyorsabb mint az érték szerinti.

Régebben a jobb teljesítmény elérése miatt nagy figyelmet kellett fordítani a paraméterátadás eme módjára, viszont a PHP 5.0 óta megjelent a "copy on write" technika, melynek lényege, hogy az érték szerint átadott paraméter nem másolódik le a hívás pillanatában.
A másolás csak abban az esetben történik meg, ha módosításra, írásra kerülne sor.

isset() vs. array_key_exists()

A teszthez egy 1000 elemű tömböt használtunk véletlen kulcs lekérdezéssel, 1000-s iterációval

    reset($tmp);
    $i = 1000;
    while($i){
        isset($tmp[rand(0,999)]);
        $i--;  
    };

    reset($tmp);
    $i = 1000;
    while($i){
        array_key_exists(rand(0,999), $tmp);
        $i--;  
    };

Figyelmeztetés:

Az isset() false értéket fog visszaadni, ha a kulcs létezik, de annak taralma NULL. pl.: array(1=>null, 2=>'a') az 1 kulcs létezik, de az isset() false-nak jelöli!

Konklúzió:

Az isset() messze gyorsabb volt mint az array_key_exists(), azonban a fent említett NULL érték esetén az isset() hamis eredményt ad.

in_array() vs in_array() !strict

A teszthez egy 1000 elemű tömböt használtunk véletlen érték lekérdezéssel, 1000-s iterációval, az értékek string-ként voltak bejegyezve

    reset($tmp);
    $i = 1000;
    while($i){
        in_array(rand(0,999), $tmp);
        $i--;  
    };

    reset($tmp);
    $i = 1000;
    while($i){
        in_array(rand(0,999), $tmp, true);
        $i--;  
    };

Konklúzió:

Várható volt az in_array() strict módban való használatának előnye, de hogy ez közel 30%-t fog jelenteni, azt nem gondoltam. Érdemes a strict módot használni!