Externe bestanden
Er zijn verschillende redenen om je applicatie uit meerdere bestanden te laten bestaan. Zoals overzicht of script die door derden worden gebouwd. Elk script dient echter weer apart geinclude te worden in je applicatie. Dit kan gebeuren door middel van include of require (_once).
Ik wil hier gaan testen welke invloed het heeft om te includen door overvloedig te includen. Ik hoop hieruit een aantal interessante conclusies te kunnen trekken.
Lege includes
Allereerst heb ik een map gemaakt met 100 lege php bestanden. Welke ik op verschillende manieren wil gaan includen.
Code (php)
In dit stukje code heb ik steeds de include vervangen door include_once, require of require_once. De resultaten worden gecached in de external_files.txt. Hier de uitslag naar 20 requests (maal 100 includes):
De tijd geeft overigens de tijd aan voor de 100 includes in totaal (in seconden).
Code (php)
1
2
3
4
5
2
3
4
5
lege loop: 0.00009784698486
include: 0.021689617633819
include_once: 0.022119426727295
require: 0.021599543094634
require_once: 0.020833826065063
include: 0.021689617633819
include_once: 0.022119426727295
require: 0.021599543094634
require_once: 0.020833826065063
Conclusie
Zoals te zien zijn de verschillen erg minimaal bij lege bestanden. Wat me opviel bij het doen van de tests, dat apache het nog sterk optimaliseerd. De eerste set includes die ik deed was maarliefst 0,06s trager gemiddeld gezien over 20 requests. Op zich niet zo heel denderend, maar wel ongeveer 30%!!
Overigens mag het voor zichzelf spreken dat includes het geheel wel vertragen, ten opzichte van geen includes.
Gevulde includes
Daar alle content die er in een include staat ook geinitialiseerd wordt, is het van belang om ook een realistische test uit te voeren met gevulde bestanden. De vraag is echter, wat zet je in zo'n bestand. Ik zou kunnen werken met output (echo), functies of classes. Of gewoon een losse berekening.
Ik maak eerst een map met weer 100 bestanden waarin de volgende regel staat:
Code (php)
1
2
3
2
3
<?
echo 'PHPhulp performance test tutorial. Testing the php performance of some output.<br/>';
?>
echo 'PHPhulp performance test tutorial. Testing the php performance of some output.<br/>';
?>
Verder gebruik ik weer dezelfde code als in de voorgaande test. Ik zal nu echter output terugkrijgen. Ik heb tevens een loopje laten draaien met de echo regel van hierboven erin.
Dit zijn de resultaten, wederom na 20 requests.
Code (php)
1
2
3
4
5
6
2
3
4
5
6
lege loop: 0.00009784698486
echo loop: 0.00042909383773805
include: 0.026817965507506
include_once: 0.026759719848634
require: 0.02636524438858
require_once: 0.025042641162872
echo loop: 0.00042909383773805
include: 0.026817965507506
include_once: 0.026759719848634
require: 0.02636524438858
require_once: 0.025042641162872
Concluse
We zien een lichte toename in de parsetijd van het script, over de gehele linie. Echter zit er geen uitschieter bij. De keuze van een include methode heeft een verwaarloosbare invloed op de performance van je site. Het includen in zijn geheel heeft echter zeker wel invloed op je script. Minder includes betekend meer performance. Zeker ook als je het vergelijkt met de echo loop. Deze is een stuk trager dan een lege loop. Echter is de include loop een veel grotere vertragende factor dan de echo regel.
Voor veel applicaties zal dit niet opgaan omdat in verschillende bestanden verschillende output wordt gegenereerd. Echter bibliotheken kunnen beter zoveel mogelijk in één bestand gegooid worden voor optimale performance (dan ben je wel op de milisecondes aan het letten, maar met 1000 requests per minuut zou dit toch een voordeel kunnen zijn).
Externe classes
Omdat het veel voorkomt dat ieder klasse zijn eigen bestand krijgt, is het leuk om te kijken hoe de performance zich verhoudt met losse bestanden of een library file.
Ik heb 100 bestanden gegenereerd met de volgende code:
Code (php)
Ik ga de tests alleen uitvoeren met een include statement.
Na 50 request komt de include tijd van 100 object files op 0.024083886146544 seconden. Dit is ongeveer gelijk aan het echo statement.
Ik ga nu een gecompileerde versie bouwen en deze in één keer includen.
De includetime bedraagt dan:0.0064766407012939 seconden.
Dit is ongeveer 4x sneller dan alle includes los te doen.
Conclusie
Het is lonend om een library te compileren vanuit al je classes. Absoluut scheelt het niet veel, maar wederom, procentueel gezien kan hierdoor een flinke winst gerealiseerd worden. Ook require_once requisten kun je hiermee vermijden waardoor je code toch weer een tik sneller wordt.