Saturday, September 22. 2007
7 tips for lightning fast PHP sites
Note: This was intended as a spoof. After laughing (or not) at the 'evidence' see my follow up post for how I think a benchmark should really be run.
I was recently creating a small tool in PHP and found myself hitting the max execution time and getting a fatal error. As it was only for my personal use I just bumped up the max execution time but it made me stop and think about how I could improve the speed of those scripts I do put up for public use. Most people aren't going to wait for 60 seconds for a page to load.
Naturally I hit the internet looking for tips. Blog posts, apparently entire blogs, forum posts and even dynamic web pages are devoted to speeding up our PHP based websites. Although these provide some information on small improvements I wanted more.
I set out to investigate whether there are any functions in PHP which perform similar tasks but where one function is faster than another. str_replace and preg_replace are fairly well known examples but I wanted to find others.
Test Environment
All tests were run on on a VIA Nehemiah 999 MHz with 480 Mb RAM (my gaming rig
) running Windows XP Professional SP2 and PHP 5.2.1. The code used to run these tests can be downloaded. In summary all tests were run 1 million times so that any potential errors averaged out.
1. sizeof vs count
First up are the sizeof and count functions. They can both be used to count the number of items in an array but does one do it better?
sizeof vs count
sizeof: 3.75928902626 seconds
count: 3.33035206795 seconds
Time saved: 0.428936958313 seconds; 12.8796280262%
The evidence says yes. The count function was over 12% faster in this test. Both functions are fast though taking 3-4 microseconds to count an array with 100,000 items. You might think it isn't worth it but remember count is also a character shorter. Not only is it faster to run but it is also faster to type!
I was recently creating a small tool in PHP and found myself hitting the max execution time and getting a fatal error. As it was only for my personal use I just bumped up the max execution time but it made me stop and think about how I could improve the speed of those scripts I do put up for public use. Most people aren't going to wait for 60 seconds for a page to load.
Naturally I hit the internet looking for tips. Blog posts, apparently entire blogs, forum posts and even dynamic web pages are devoted to speeding up our PHP based websites. Although these provide some information on small improvements I wanted more.
I set out to investigate whether there are any functions in PHP which perform similar tasks but where one function is faster than another. str_replace and preg_replace are fairly well known examples but I wanted to find others.
Test Environment
All tests were run on on a VIA Nehemiah 999 MHz with 480 Mb RAM (my gaming rig
) running Windows XP Professional SP2 and PHP 5.2.1. The code used to run these tests can be downloaded. In summary all tests were run 1 million times so that any potential errors averaged out.1. sizeof vs count
First up are the sizeof and count functions. They can both be used to count the number of items in an array but does one do it better?
sizeof vs count
sizeof: 3.75928902626 seconds
count: 3.33035206795 seconds
Time saved: 0.428936958313 seconds; 12.8796280262%
The evidence says yes. The count function was over 12% faster in this test. Both functions are fast though taking 3-4 microseconds to count an array with 100,000 items. You might think it isn't worth it but remember count is also a character shorter. Not only is it faster to run but it is also faster to type!
2. is_int vs is_integer
Next it is time to try some validation with is_int and is_integer.
is_int vs is_integer
is_int: 3.11394786835 seconds
is_integer: 3.42630600929 seconds
Time saved: 0.312358140945 seconds; 9.11646946006%
The difference is smaller this time but again both functions are executing in a little over 3 microseconds. is_int is faster than is_integer so again the shorter function name wins. Is this going to be a pattern?
3. chop vs rtrim
Tidying up a string breaks the pattern. Maybe my analysis was a little premature.
chop vs rtrim
chop: 4.73731994629 seconds
rtrim: 4.41647195816 seconds
Time saved: 0.320847988129 seconds; 7.26480301852%
rtrim is a little faster and these functions take longer at a little over 4 microseconds.
4. doubleval vs floatval
Both these functions allow you to quickly pick a float, or double, out of a string.
doubleval vs floatval
doubleval: 4.56571412086 seconds
floatval: 4.35375285149 seconds
Time saved: 0.211961269379 seconds; 4.8684727087%
4% or 211 nanoseconds is next to nothing. I would want to use floatval but I wouldn't exactly be kicking myself if I slipped a doubleval into my code instead.
5. fwrite vs fputs
So far all the functions have been running fast anyway so the difference haven't been that significant but things are starting to get interesting with the run time jumping to 20-24 microseconds to write a short string to a file.
fwrite vs fputs
fwrite: 24.9826359749 seconds
fputs: 20.1990799904 seconds
Time saved: 4.7835559845 seconds; 23.6820488199%
With a difference of over 4 microseconds you could run both fputs and floatval in the time it takes to run fwrite. The difference is over 23% which clearly makes fputs the better function. It's shorter as well.
6. implode vs join
This one really surprised me. I expected these functions to be faster. Both these functions allow you to convert an array into a string. implode is the opposite of explode and join allows you to join the items in an array with a 'glue' string. In this case the array had 100 items.
implode vs join
implode: 47.2712550163 seconds
join: 50.1287050247 seconds
Time saved: 2.85745000839 seconds; 5.70022705949%
5% doesn't seem like all that much but 2 microseconds shouldn't be ignored.
7. ini_alter vs ini_set
Finally lets look at modifying the environment. I actually cheated here and just set the max execution time to 60 seconds a million times. I think the result is still valid though
ini_alter vs ini_set
ini_alter: 103.332370043 seconds
ini_set: 86.2883789539 seconds
Time saved: 17.0439910889 seconds; 19.7523598143%
As might be expected these functions are expensive when it comes to execution time. That 17 microsecond saving is massive as well making ini_set the superior choice.
Speedy sites
PHP has a vast array of functions enabling a large variety of tasks to be performed without the programmer 'reinventing the wheel'. These functions are not all created equal though and real speed boosts can be achieved by choosing the right functions.
Next week I'll be posting even more performance enhancements and you can be the first to know by subscribing to the feed.
Next it is time to try some validation with is_int and is_integer.
is_int vs is_integer
is_int: 3.11394786835 seconds
is_integer: 3.42630600929 seconds
Time saved: 0.312358140945 seconds; 9.11646946006%
The difference is smaller this time but again both functions are executing in a little over 3 microseconds. is_int is faster than is_integer so again the shorter function name wins. Is this going to be a pattern?
3. chop vs rtrim
Tidying up a string breaks the pattern. Maybe my analysis was a little premature.
chop vs rtrim
chop: 4.73731994629 seconds
rtrim: 4.41647195816 seconds
Time saved: 0.320847988129 seconds; 7.26480301852%
rtrim is a little faster and these functions take longer at a little over 4 microseconds.
4. doubleval vs floatval
Both these functions allow you to quickly pick a float, or double, out of a string.
doubleval vs floatval
doubleval: 4.56571412086 seconds
floatval: 4.35375285149 seconds
Time saved: 0.211961269379 seconds; 4.8684727087%
4% or 211 nanoseconds is next to nothing. I would want to use floatval but I wouldn't exactly be kicking myself if I slipped a doubleval into my code instead.
5. fwrite vs fputs
So far all the functions have been running fast anyway so the difference haven't been that significant but things are starting to get interesting with the run time jumping to 20-24 microseconds to write a short string to a file.
fwrite vs fputs
fwrite: 24.9826359749 seconds
fputs: 20.1990799904 seconds
Time saved: 4.7835559845 seconds; 23.6820488199%
With a difference of over 4 microseconds you could run both fputs and floatval in the time it takes to run fwrite. The difference is over 23% which clearly makes fputs the better function. It's shorter as well.
6. implode vs join
This one really surprised me. I expected these functions to be faster. Both these functions allow you to convert an array into a string. implode is the opposite of explode and join allows you to join the items in an array with a 'glue' string. In this case the array had 100 items.
implode vs join
implode: 47.2712550163 seconds
join: 50.1287050247 seconds
Time saved: 2.85745000839 seconds; 5.70022705949%
5% doesn't seem like all that much but 2 microseconds shouldn't be ignored.
7. ini_alter vs ini_set
Finally lets look at modifying the environment. I actually cheated here and just set the max execution time to 60 seconds a million times. I think the result is still valid though
ini_alter vs ini_set
ini_alter: 103.332370043 seconds
ini_set: 86.2883789539 seconds
Time saved: 17.0439910889 seconds; 19.7523598143%
As might be expected these functions are expensive when it comes to execution time. That 17 microsecond saving is massive as well making ini_set the superior choice.
Speedy sites
PHP has a vast array of functions enabling a large variety of tasks to be performed without the programmer 'reinventing the wheel'. These functions are not all created equal though and real speed boosts can be achieved by choosing the right functions.
Next week I'll be posting even more performance enhancements and you can be the first to know by subscribing to the feed.
Comments
Display comments as
(Linear | Threaded)
Nice benchmarks. But I doubt following those steps will make your site "lightning fast". I thought I was going to read seven magical tips when I clicked the link in my Google reader 
#1
on
2007-09-22 18:59
So, in general, using a non-alias function if faster than using an alias. No surprise there, really.
Strangely enough fputs was faster even though it is an alias to fwrite, according to php.net anyway. Perhaps fwrite is the alias after all, although the speed differences probably have more to do with the storage device not running at constant speed rather than PHP.
Also, the speed differences aren't really that huge I would have to say that there is more danger in an alias being dropped off of PHP - preventing you from upgrading - than an alias crippling your site.
Strangely enough fputs was faster even though it is an alias to fwrite, according to php.net anyway. Perhaps fwrite is the alias after all, although the speed differences probably have more to do with the storage device not running at constant speed rather than PHP.
Also, the speed differences aren't really that huge
I would have to say that there is more danger in an alias being dropped off of PHP - preventing you from upgrading - than an alias crippling your site.
#2
on
2007-09-22 19:45
For those looking for string speed comparisons I have this page (and source) for comparison of various types of string usage.
http://pear.reversefold.com/strings/
http://pear.reversefold.com/strings/
In the PHP internals, an aliased function is just another entry in a hash table. In simplistic terms, the count function is something like this:
function count($arr) {
return $arr->numberOfElements;
}
and since sizeof is an alias, it is effectively:
function sizeof($arr) {
return $arr->numberOfElements;
}
it is not:
function sizeof($arr) {
return count($arr);
}
in other words, there is absolutely no additional overhead for calling an aliased function; it is literally the same code path, with the only difference being the name of the function.
The fact that you are seeing a difference is because your benchmark is "bad".
Ideally, you want to run your benchmarks for several minutes so that you can smooth over various systemic influences. For instance, on your first run, your kernel might need to swap some pages around. On the second run, those pages might be fine. These and other influences can effect pretty big spikes in short lived benchmarks.
I've talked about this in the past: http://netevil.org/blog/2005/sep/benchmarking-in-general
The other thing to consider is this:
When your page takes 60 seconds to load it's time to break out the profiler to find out where the bottleneck is and optimize that, as that will give you the most gain.
http://en.wikipedia.org/wiki/Pareto_principle
function count($arr) {
return $arr->numberOfElements;
}
and since sizeof is an alias, it is effectively:
function sizeof($arr) {
return $arr->numberOfElements;
}
it is not:
function sizeof($arr) {
return count($arr);
}
in other words, there is absolutely no additional overhead for calling an aliased function; it is literally the same code path, with the only difference being the name of the function.
The fact that you are seeing a difference is because your benchmark is "bad".
Ideally, you want to run your benchmarks for several minutes so that you can smooth over various systemic influences. For instance, on your first run, your kernel might need to swap some pages around. On the second run, those pages might be fine. These and other influences can effect pretty big spikes in short lived benchmarks.
I've talked about this in the past: http://netevil.org/blog/2005/sep/benchmarking-in-general
The other thing to consider is this:
When your page takes 60 seconds to load it's time to break out the profiler to find out where the bottleneck is and optimize that, as that will give you the most gain.
http://en.wikipedia.org/wiki/Pareto_principle
When you do benchmarking on Windows you'll always get funny behavior, try using some flavor of Linux where the majority of apps are deployed.
Here is what I got running the tests on my CentOS box.
sizeof vs count
sizeof: 1.18344593048 seconds
count: 1.18188285828 seconds
is_int vs is_integer
is_int: 1.13039302826 seconds
is_integer: 1.14828205109 seconds
and so forth
Here is what I got running the tests on my CentOS box.
sizeof vs count
sizeof: 1.18344593048 seconds
count: 1.18188285828 seconds
is_int vs is_integer
is_int: 1.13039302826 seconds
is_integer: 1.14828205109 seconds
and so forth
Be careful when interpreting the results; these changes aren't going to make your website 10% faster; so you get .3 seconds gain if you run it a million times. But most scripts are running it only once, and the time that count/sizeof is taking compared to the all the other things that are happening is probably tiny.
i'm actually a fans of sizeof instead of count. i just get used.
so now i've to change it. thanks anyway...
so now i've to change it. thanks anyway...
Why are clueless morons allowed into Planet PHP?
#8
on
2007-09-23 11:49
Please see the following post for my reasoning behind this post.
http://torrentialwebdev.com/blog/archives/118-Better-Benchmarks.html
Please direct all comments towards that post.
http://torrentialwebdev.com/blog/archives/118-Better-Benchmarks.html
Please direct all comments towards that post.
The author does not allow comments to this entry
Following one too many posts talking about increasing the speed of PHP scripts by using single quotes instead of double quotes, preincrementing rather than postincrementing variables and the like I wrote 7 tips for lightning fast PHP sites. This post was
Tracked: Sep 23, 21:27