Testy szybkości i ciekawe wyniki, Porównanie szybkości działania funkcji z parametrami różnego typu Opcje

[gWd]

Wykonałem krótkie testy porównujące szybkości działania funkcji z parametrem przekazanym przez wartość, referencję i obiekt. Musze przyznać, że wyniki troche mnie zaskoczyły.

Środowisko:
PHP 5.2.1RC2
Apache 2.2.4

Przykład 1

[PHP] pobierz, plaintext 
<?php
class C1
{
	public $data=array();
 
	public function UstawZTablicy ($tab)
	{
		foreach ($tab as $key => $value)
		{
			$this->data[$key] = $value;
		}
	}
	public function ObjMet()
	{
		echo $this->data['pole8455'];
	}
}
 
function Tab ($tab)
{
	echo $tab['pole8455'];
}
 
function TabRef (&$tab)
{
	echo $tab['pole8455'];
}
 
function ObjFunc ($obj)
{
	echo $obj->pole8455;
}
 
$tab = array();
for ($ptl=1; $ptl<10000; $ptl++)
{
	$tab['pole'.$ptl] = $ptl;
}
$obj = new C1();
$obj->UstawZTablicy($tab);
 
$timeTests = array();
 
$timeTests[0]['czas'] = microtime(true);
$timeTests[0]['znak'] = 'start';
 
//test funkcji z parametrem wartosciowym
for ($ptl=0; $ptl<4000; $ptl++)
{
	Tab($tab);
}
 
$timeTests[4]['czas'] = microtime(true);
$timeTests[4]['znak'] = 'Tab';
 
//test funkcji z przekazaniem jej parametru: obiekt
for ($ptl=0; $ptl<4000; $ptl++)
{
	ObjFunc($obj);
}
 
$timeTests[1]['czas'] = microtime(true);
$timeTests[1]['znak'] = 'ObjFunc';
 
//test metody obiektu
for ($ptl=0; $ptl<4000; $ptl++)
{
	$obj->ObjMet();
}
 
$timeTests[2]['czas'] = microtime(true);
$timeTests[2]['znak'] = 'ObjMet';
 
//test funkcji z parametrem referencyjnym
for ($ptl=0; $ptl<4000; $ptl++)
{
	TabRef($tab);
}
 
$timeTests[3]['czas'] = microtime(true);
$timeTests[3]['znak'] = 'TabRef';
 
 
echo '<br />';
$timePrev = 0;
foreach ($timeTests as $time)
{
	echo $time['znak'].': '.($time['czas'] - $timePrev).'<br />';
	$timePrev = $time['czas'];
}
?>
[PHP] pobierz, plaintext 

Średnie wyniki z 10 pomiarów:
ObjFunc: 0,03630816936492920
ObjMet: 0,01625814437866210
Tab: 0,02549026012420650
TabRef: 0,01591291427612310

Opis wyników
ObjFunc jest 2x wolniejsze niż wywołanie metody obiektu ObjMet
Tab jest 1.6x wolniejsze od funkcji z parametrem referencyjnym!!!

Wnioski
1. Okazuje się, że wbrew dokumentacji PHP, przekazanie parametu przez referencję jest dużo szybsze niż przekazanie wartości. Należy się domyślać, że dotyczy to raczej zmiennych o dość rozmiarach.
2. Wywołanie metody obiektu jest znacznie szybsze niż (trochę dziwna) funkcja.

Drugi test jest jeszcze ciekawszy!
Tym razem modyfikujemy zmienną przekazaną do funkcji/metody.

Przykład 2

[PHP] pobierz, plaintext 
<?php
class C1
{
	public $data=array();
 
	public function UstawZTablicy ($tab)
	{
		foreach ($tab as $key => $value)
		{
			$this->data[$key] = $value;
		}
	}
	public function ObjMet()
	{
		$this->data['pole8455'] = 34534;
	}
}
 
function Tab ($tab)
{
	$tab['pole8455'] = 34534;
}
 
function TabRef (&$tab)
{
	$tab['pole8455'] = 34534;
}
 
function ObjFunc ($obj)
{
	$obj->pole8455 = 34534;
}
 
$tab = array();
for ($ptl=1; $ptl<10000; $ptl++)
{
	$tab['pole'.$ptl] = $ptl;
}
$obj = new C1();
$obj->UstawZTablicy($tab);
 
$timeTests = array();
 
$timeTests[0]['czas'] = microtime(true);
$timeTests[0]['znak'] = 'start';
 
//test funkcji z parametrem wartosciowym
for ($ptl=0; $ptl<4000; $ptl++)
{
	Tab($tab);
}
 
$timeTests[4]['czas'] = microtime(true);
$timeTests[4]['znak'] = 'Tab';
 
//test funkcji z przekazaniem jej parametru: obiekt
for ($ptl=0; $ptl<4000; $ptl++)
{
	ObjFunc($obj);
}
 
$timeTests[1]['czas'] = microtime(true);
$timeTests[1]['znak'] = 'ObjFunc';
 
//test metody obiektu
for ($ptl=0; $ptl<4000; $ptl++)
{
	$obj->ObjMet();
}
 
$timeTests[2]['czas'] = microtime(true);
$timeTests[2]['znak'] = 'ObjMet';
 
//test funkcji z parametrem referencyjnym
for ($ptl=0; $ptl<4000; $ptl++)
{
	TabRef($tab);
}
 
$timeTests[3]['czas'] = microtime(true);
$timeTests[3]['znak'] = 'TabRef';
 
 
echo '<br />';
$timePrev = 0;
foreach ($timeTests as $time)
{
	echo $time['znak'].': ';
	echo ($time['czas'] - $timePrev).'<br />';
	$timePrev = $time['czas'];
}
?>
[PHP] pobierz, plaintext 

Średnie wyniki z 10 pomiarów:
ObjFunc: 0,00535948276519776
ObjMet: 0,00558812618255616
Tab: 12,12336094379430000
TabRef: 0,00451698303222655

Opis wyników
ObjFunc i ObjMet mają bardzo zbliżone wyniki.
Zaskakuje natomiast funkcja Tab z wynikiem ponad 2000x gorszym od innych sposobów!!!! w tym od funkcji z parametrem referencyjnym.

Wnioski
1. Porównując wyniki z Przykładu 1 i 2 widzimy, że PHP wykonując funkcję z parametrem wartościowym nie tworzy kopii tego paremetru za każdym razem. Taka kopia generowana jest tylko wtedy, gdy zmienna ulega zmianie wewnątrz funkcji!
2. Przekazywanie do funkcji dużych zmiennych przez wartość jest wolniejsze niż przekazanie ich przez referencję, nawet jeśli zmienna nie ulega modyfikacji wewnątrz funkcji!
3. Wywoływanie i działanie fukcji/metod na obiektach może być nieco wolniejsze od funkcji na tablicach, ale różnica nie jest duża.

Ten post edytował gWd 18.04.2007, 12:19:17

[gWd]

Teraz wykonamy wersję testu 1, ale tym razem z 10x mniejszą zmienną.

Przykład 3

[PHP] pobierz, plaintext 
<?php
class C1
{
	public $data=array();
 
	public function UstawZTablicy ($tab)
	{
		foreach ($tab as $key => $value)
		{
			$this->data[$key] = $value;
		}
	}
	public function ObjMet()
	{
		echo $this->data['pole845'];
	}
}
 
function Tab ($tab)
{
	echo $tab['pole845'];
}
 
function TabRef (&$tab)
{
	echo $tab['pole845'] = 34534;
}
 
function ObjFunc ($obj)
{
	echo $obj->pole845;
}
 
$tab = array();
for ($ptl=1; $ptl<1000; $ptl++)
{
	$tab['pole'.$ptl] = $ptl;
}
$obj = new C1();
$obj->UstawZTablicy($tab);
 
$timeTests = array();
 
$timeTests[0]['czas'] = microtime(true);
$timeTests[0]['znak'] = 'start';
 
//test funkcji z parametrem wartosciowym
for ($ptl=0; $ptl<4000; $ptl++)
{
	Tab($tab);
}
 
$timeTests[4]['czas'] = microtime(true);
$timeTests[4]['znak'] = 'Tab';
 
//test funkcji z przekazaniem jej parametru: obiekt
for ($ptl=0; $ptl<4000; $ptl++)
{
	ObjFunc($obj);
}
 
$timeTests[1]['czas'] = microtime(true);
$timeTests[1]['znak'] = 'ObjFunc';
 
//test metody obiektu
for ($ptl=0; $ptl<4000; $ptl++)
{
	$obj->ObjMet();
}
 
$timeTests[2]['czas'] = microtime(true);
$timeTests[2]['znak'] = 'ObjMet';
 
//test funkcji z parametrem referencyjnym
for ($ptl=0; $ptl<4000; $ptl++)
{
	TabRef($tab);
}
 
$timeTests[3]['czas'] = microtime(true);
$timeTests[3]['znak'] = 'TabRef';
 
 
echo '<br />';
$timePrev = 0;
foreach ($timeTests as $time)
{
	echo $time['znak'].': ';
	echo ($time['czas'] - $timePrev).'<br />';
	$timePrev = $time['czas'];
}
?>
[PHP] pobierz, plaintext 

Średnie wyniki z 10 pomiarów:
ObjFunc: 0,04068577289581310
ObjMet: 0,03742690086364740
Tab: 0,01934800148010270
TabRef: 0,03726780414581290

Opis wyników
Tab jest 2x szybsze od TabRef

Wnioski
W porównaniu do przykładu 1, widzimy dużo lepsze wyniki funkcji Tab. Dlatego łatwo można wyciągnąć wniosek, że funkcja z parametrem wartościowym jest jednak szybsza od fukcji z parametrem referencyjnym. Przekazanie tablicy przez referencję jest porównywalnie szybkie jak przekazanie obiektu lub wywołanie metody obiektu.

I ostatni test
Tym razem zmiejszyłem rozmiar zmiennej do 10 pól integer (z 10000 w pierwszym teście) i wykonałem funkcje modyfikujące przekazaną zmienną, tym razem równierz funckaj Tab, która nieznacznie zmieniłem, aby zwracała zmienną o nowej wartości.

Przykład 4

[PHP] pobierz, plaintext 
<?php
class C1
{
	public $data=array();
 
	public function UstawZTablicy ($tab)
	{
		foreach ($tab as $key => $value)
		{
			$this->data[$key] = $value;
		}
	}
	public function ObjMet()
	{
		$this->data['pole8'] = 34534;
	}
}
 
function Tab ($tab)
{
	$tab['pole8'] = 34534;
	return $tab;
}
 
function TabRef (&$tab)
{
	$tab['pole8'] = 34534;
}
 
function ObjFunc ($obj)
{
	$obj->pole8 = 34534;
}
 
$tab = array();
for ($ptl=1; $ptl<10; $ptl++)
{
	$tab['pole'.$ptl] = $ptl;
}
$obj = new C1();
$obj->UstawZTablicy($tab);
 
$timeTests = array();
 
$timeTests[0]['czas'] = microtime(true);
$timeTests[0]['znak'] = 'start';
 
//test funkcji z parametrem wartosciowym
for ($ptl=0; $ptl<4000; $ptl++)
{
	$tab = Tab($tab);
}
 
$timeTests[4]['czas'] = microtime(true);
$timeTests[4]['znak'] = 'Tab';
 
//test funkcji z przekazaniem jej parametru: obiekt
for ($ptl=0; $ptl<4000; $ptl++)
{
	ObjFunc($obj);
}
 
$timeTests[1]['czas'] = microtime(true);
$timeTests[1]['znak'] = 'ObjFunc';
 
//test metody obiektu
for ($ptl=0; $ptl<4000; $ptl++)
{
	$obj->ObjMet();
}
 
$timeTests[2]['czas'] = microtime(true);
$timeTests[2]['znak'] = 'ObjMet';
 
//test funkcji z parametrem referencyjnym
for ($ptl=0; $ptl<4000; $ptl++)
{
	TabRef($tab);
}
 
$timeTests[3]['czas'] = microtime(true);
$timeTests[3]['znak'] = 'TabRef';
 
 
echo '<br />';
$timePrev = 0;
foreach ($timeTests as $time)
{
	echo $time['znak'].': ';
	echo ($time['czas'] - $timePrev).'<br />';
	$timePrev = $time['czas'];
}
?>
[PHP] pobierz, plaintext 

Średnie wyniki z 10 pomiarów:
ObjFunc: 0,01284565925598150
ObjMet: 0,01222741603851320
Tab: 0,03661031723022470
TabRef: 0,01396517753601080

Opis wyników
Tab jest (tylko) 2.6x wolniejsza od TabRef.

Wnioski
1. Jeżeli w wyniku działania funkcji zmienna ma ulec zmianie, to przekazanie do funkcji nawet stosunkowo małych zmiennych przez referencję jest korzystniejsze niż przekaznie ich przez wartość.
2. Dlatego może się opłacać zamienieie tablicy na obiekt, albo wogle korzystanie z samych obiektów.

Ten post edytował gWd 18.04.2007, 13:18:16