mysql_fetch_array() vs. mysql_fetch_object() (2)

Door AtleX op zaterdag 8 december 2007 10:45 - Reacties (6)
Categorie: PHP, Views: 4.862

Dit artikel is het beloofde vervolg op mysql_fetch_array() vs. mysql_fetch_object(). In dit artikel ga ik in dieper in op de verschillen in prestaties tussen deze 2 functies, onder andere het verschil in lezen uit objecten en arrays.

Ik zal eerst mijn testmethode eens toelichten. In mijn vorige post over dit onderwerp liet ik al het stuk code zien dat ik gebruikt heb. Deze code heb ik 20x uitgevoerd. 10x op mijn gewone PC (Windows XP SP2) met WampServer en 10x op mijn testserver met Debian Linux. Beide systemen beschikken over dezelfde versie van Apache, PHP en MySQL, al verschilt het platform natuurlijk.

Qua hardware zit er ook een wereld van verschil tussen. Zo beschikt mijn PC over een Core 2 Duo E6400 CPU met 2GB geheugen, en mijn server is slechts een schamele P3 1GHz met 512MB SDRAM.

Van die 20 metingen neem ik het gemiddelde, wat dus het resultaat is. Qua geheugengebruik zijn ze altijd behoorlijk vergelijkbaar, maar ik heb gezien dat PHP op mijn gewone PC onder XP soms een stuk langzamer is dan onder Linux. Op de Debian installatie op mijn PC haal ik soms flink hogere prestaties met dezelfde PHP versie, maar waar dat aan ligt weet ik niet. Zolang ik dat niet weet voer ik tijd metingen alleen op mijn PC uit, en niet op mijn server. De resultaten zijn consistent, gemeten over meerdere dagen, dus dat lijkt me geen probleem.

Dan nu, de test. Wat ik wilde weten is of het lezen uit een array sneller is dan uit een object. Daarvoor heb ik de volgende code toegevoegd:

PHP:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
// *snip*
$benchmark->StartSection("read_array");
for ($i = 0; $i < 10000; $i++)
{
    $arrayResults[$i] = $arrayResults[$i]["numberOfMonths"];
}
$benchmark->EndSection("read_array");

// *snip*

$benchmark->StartSection("read_object");
for ($i = 0; $i < 10000; $i++)
{
    $arrayResults[$i] = $arrayResults[$i]->numberOfMonths;
}
$benchmark->EndSection("read_object");
// *snip*



Op zich zijn de resultaten niet erg verrassend, het presteert ongeveer gelijk:
FunctieTijd, in seconden
mysql_fetch_array()0.0189
mysql_fetch_object()0.0151


Dit is dus gemeten over een loop met 10000 iteraties. Een verschil van ongeveer 0.003 seconden is dan verwaarloosbaar.

Volgende: Supreme Commander 12-'07 Supreme Commander
Volgende: We've got a winner 12-'07 We've got a winner

Reacties


Door Tweakers user EdwinG, zaterdag 8 december 2007 12:42

Verschil van 0,003
Lijkt misschien weinig, maar is gezien de totale tijd wel 20%

Door Tweakers user AtleX, zaterdag 8 december 2007 13:59

Staat er toch ook :? En 20% klink misschien leuk, als je het echt over grote verschillen hebt. Bij zo'n verschil van 0.003 seconden is het niet eens de moeite waard om het in procenten uit te drukken.

Door Tweakers user Hielko, zaterdag 8 december 2007 15:34

Als je hetzelfde denkt bij elke statement die je schrijft heb je uiteindelijk wel een programma dat 20% langzamer is.

Door Tweakers user AtleX, zaterdag 8 december 2007 15:38

Blijft de vraag of jij het verschil tussen 0.02 of 0.03 seconden merkt. En wie zegt dat ik dat bij elk statement denk? Als ik dat zou doen zou ik niet zoveel tijd aan performancetests en optimalisatie besteden. :z

Door Tweakers user AtleX, zaterdag 8 december 2007 15:41

En bij gebrek aan een edit mogelijkheid: de tijden in mijn vorige post zijn compleet uit te lucht gegrepen.

Door Tweakers user P_de_B, maandag 10 december 2007 15:51

Tja, en als je bij elke routine probeert van 0,003 naar 0,002 te gaan heb je een product dat nooit af komt, of onbetaalbaar is vanwege de grote hoeveelheid uren die je erin hebt gestoken.

Optimalisatie is prima, maar weet wel waar je het moet toepassen en besteed niet te veel aandacht aan microoptimalisaties die je niet terugziet in je uiteindelijke performance.

Reageren is niet meer mogelijk