[PHP]Optimalisatie

[Data-base]

Goededag,

Voor een project wat enigszins geoptimaliseerd moet worden ging ik op internet op zoek naar optimalisatietechnieken. Na wat dingen te hebben gelezen ging ik zelf eens wat benchmarken en ik kwam het volgende bizarre geval tegen:

for-loop 1:

PHP:

$timer->start();
//==============START TEST==================//
for($i = sizeof($a); $i <= 0; $i--)
{
    $c[$i] =& $a[$i];
}
//==============STOP TEST==================//
$timer->stop();

for-loop2:

PHP:

$timer->start();
//==============START TEST==================//
$size = sizeof($a);
for($i = 0; $i <= $size; $i++)
{
    $c[$i] =& $a[$i];
}
//==============STOP TEST==================//
$timer->stop();

$a is een 1d array met 1.000.000 elementen.

Executietijd hiervan op een gewone versie van php zonder optimizers of dergelijke:
for1 : 0.00027203559875488
for2 : 1.8486249446869

En het enige significante verschil wat ik hier uit kan halen is het feit dat bij for 1 er 1e6 keer word vergeleken met een constante en bij for-2 er 1e6 keer word vergeleken met een variable.
Vertaal ik dit nu echter naar een while:

PHP:

$timer->start();
//==============START TEST==================//
$i = sizeof($a);
while( $i >= 0)
{
    $c[$i] =& $a[$i];
    $i--;
}
//==============STOP TEST==================//
$timer->stop();

Neemt de executietijd plots toch naar 1.17 sec (for2 was 1.90 sec, dus dit is weer net iets beter).

Dit vind ik raar, ligt dit nu aan de "brakke" interpreter/parser van php die slecht optimaliseert, of is er iets wat ik over het hoofd zie waardoor de executietijden logisch te verklaren zijn?


PS: Voor de volledigheid hier de complete code met de bijbehorende uitvoer:

PHP:

$timer = new timer();

$a = array();
$c = array();
for ($i=0; $i < 1000000; $i++)
{
    $a[$i] = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
}

$timer->start();
//==============START TEST==================//
for($i = sizeof($a); $i <= 0; $i--)
{
    $c[$i] =& $a[$i];
}
//==============STOP TEST==================//
$timer->stop();
echo 'for1 :'.$timer->getTime().'<br />';

//============CLEAR====================/
$timer->clear();
unset($c);
$c = array();
//============/CLEAR====================/

$timer->start();
//==============START TEST==================//
$size = sizeof($a);
for($i = 0; $i <= $size; $i++)
{
    $c[$i] =& $a[$i];
}
//==============STOP TEST==================//
$timer->stop();
echo 'for2 :'.$timer->getTime().'<br />';

//============CLEAR====================/
$timer->clear();
unset($c);
$c = array();
//============/CLEAR====================/

$timer->start();
//==============START TEST==================//
$i = sizeof($a);
while( $i >= 0)
{
    $c[$i] =& $a[$i];
    $i--;
}
//==============STOP TEST==================//
$timer->stop();
echo 'while1 :'.$timer->getTime().'<br />';

code:

for1 :0.00027799606323242
for2 :1.9117231369019
while1 :1.7238299846649

[Verwijderd]

Met i<=0 loopt die for-loop 1 natuurlijk niet...

[Data-base]

Ik schaam me dood Slotje..

[ Voor 18% gewijzigd door Data-base op 10-06-2007 22:15 ]

[Verwijderd]

Data-base zou je het nieuwe resultaat van for1-loop erbij willen plaatsen?

edit:

leuke interessante php-benchies

[ Voor 41% gewijzigd door Verwijderd op 10-06-2007 23:50 ]

[Data-base]

Ja hoor, die eerste for levert nu gemiddeld

1.8932721614838

Dus net een tikje sneller
En die site was ik ook tegengekomen ja

[ACM]

Data-base schreef op maandag 11 juni 2007 @ 23:50:
Dus net een tikje sneller
En die site was ik ook tegengekomen ja

Het enige verschil tussen je for1 en for2 is natuurlijk de volgorde van het aftellen of optellen. Dat is wel heel erg micro-optimaliseren. Het kan zelfs ongewenst gedrag zijn, bovendien is het voor $c benodigde geheugen dan al gealloceerd, dus je hebt kans dat je ook door dat punt verschillen ziet.

't Is veel interessanter en nuttiger om het verschil hiertussen te bekijken:

PHP:

//for1
for($i = 0; $i < sizeof($a); $i++)

// for2
for($i = 0, $stop = sizeof($a); $i < $stop; $i++)

Dat is iets dat in sommige gecompileerde talen (C, Java?) nauwelijks uitmaakt maar in php vrij significant zal verschillen.

In mijn ervaring helpt het nog altijd meer om de tijd die je in queries stopt te verkleinen dan dit soort mini-dingetjes aan te passen. Wel is het zinvol om te voorkomen dat je onnodig array's en objecten maakt/vult omdat die nogal wat geheugenoverhead hebben en het voorkomen van functiecalls is natuurlijk meestal ook vrij zinvol. En als ik een loop moet gebruiken is dat bij een array met key-value paren vrijwel altijd een foreach, met een array doorgaans een for-loop en met een onbekende hoeveelheid resultaten uit een query een while-loop.

[Verwijderd]

zucht, verwijder maar.

[ Voor 94% gewijzigd door Verwijderd op 12-06-2007 10:23 . Reden: domheid ]

[TheBorg]

Alleen regular expressions kunnen erg gevaarlijk zijn voor de performance. Verder sluit ik me helemaal aan bij ACM.

[Gwaihir]

Nog zo'n mini-weetje: je kunt nog even ++$i gebruiken ipv $i++. Scheelt ca. 10%, al vist in de meeste productie situaties de Zend Optimizer dat er ook wel uit. (Laatst getest op PHP 5.1.)

[ Voor 8% gewijzigd door Gwaihir op 13-06-2007 16:20 ]

[YopY]

Laatste opmerking klopt wel, echter i++ en ++i verschillen wel:

PHP:

$i = 1;

if ($i++ == 2) // false
if (++$i == 2) // true

$i++ wordt i verhoogd nadat hij (eventueel) ergens mee vergeleken is, ++$i voordat hij vergeleken wordt.

En ik heb geen flauw idee waarom ++$i sneller is dan $i++.

[T-MOB]

YopY schreef op woensdag 13 juni 2007 @ 16:30:
Laatste opmerking klopt wel, echter i++ en ++i verschillen wel:

offtopic:
Je voorbeeld klopt niet, bij je tweede vergelijking is $i natuurlijk 3 en derhalve ook false

[Verwijderd]

YopY schreef op woensdag 13 juni 2007 @ 16:30:
En ik heb geen flauw idee waarom ++$i sneller is dan $i++.

Vrij simpel:

code:

//++$i
$i = $i+1;
return $i;

//$i++
$temp = $i;
$i = $i+1;
return $temp;

Hoewel er nog maar weinig compilers/interpreters zijn die dit niet optimaliseren...

[Gwaihir]

YopY schreef op woensdag 13 juni 2007 @ 16:30:
i++ en ++i verschillen wel

Ja, mijn opmerking was wel in context bedoeld; je kunt het probleemloos verwisselen wanneer $i++ (danwel $i--) op zichzelf staat, zoals in alle tot dan toe gegeven voorbeelden.

Op het moment dat je gaat vergelijken (zoals in jouw voorbeeld), of toewijzen ($y = $i++) zijn ze niet meer uitwisselbaar. Dan zou ik ook gewoon $i++ gebruiken als me dat uitkomt en me niet druk maken om zo'n stukje micro-optimalisatie.