PHP Performace Questions Hit List

[ganz_friedrich]

Hello all,

I was hoping someone could do a shot-gun approach on these questions to save me having to look for hours for individual answers. (They are mostly performance related questions). If any questions are stupid (as I suppose a few might be), just shoot them down breifly.

Firstly, and most importantly, does php cache the scripts that it compiles? (I'm guessing it doesn't re-compile a script every time it is requested and only checks if it has been modified). I would like to know, because if it does cache, it makes no sense to declare functions in if statements (where the purpose would be to save function space and processing) because the compiled function will be cached anyway (am i correct in thinking this?). Also, if php caches compiled scripts then there should be no performance dissadvantage to using assoc arrays as oppose to numeric array (that is, after the first complie)?

When passing variables to functions normally, is php clever enough to know only to make a copy of the variable data when necessary (i.e. passes by reference, until some change to the variable is made)? What about foreach loops, etc. is it the same for these?

Is it a lot more expensive to output concatinations of "single-quotated strings" and variables than to output everthing as one "double-quotations string" (which php checks for variables)? Or is there a faster way to output a string that needs to have variables inserted in various places? (I've heard that starting a buffer and echoing can sometimes be more efficient, but are there any other methods?)

Is it cheaper to check if a variable isset or initialize the variable and check if true/false/etc?

How expensive is changing variable types? For example, should I initialize a variable that could become an array as false or as an empty array? Obviously it depends on what is more likely to happen: if it will become a "loaded" array or not. But just suppose both are equally likely.

Are mysql queries passed by reference (to the internal php function) whereever possible? I.e. is there any advantage to the most commonly documented method of first assigning a query string to a variable and then passing this to the mysql function AS OPPOSE to just passing the string to the mysql function? My guess is that this is a stupid question - that it doesn't make a difference, but I don't know enough about php to be sure.

When passing by reference to a function, is it better to pass 1 array or serveral variables by reference?

When making variables global within a function are they then accessible as global anywhere? Or does this just make them available to the function? (i.e. is using the global statement inside a function identical to using it outside a function?)

If mysql queries are correct, can they still fail e.g. due to mysql server overload?

Very breifly, what is mysql trace mode?

[dream_scape]

Hi I can help with some of these.

ganz_friedrich wrote:

Firstly, and most importantly, does php cache the scripts that it compiles? (I'm guessing it doesn't re-compile a script every time it is requested and only checks if it has been modified). I would like to know, because if it does cache, it makes no sense to declare functions in if statements (where the purpose would be to save function space and processing) because the compiled function will be cached anyway (am i correct in thinking this?). Also, if php caches compiled scripts then there should be no performance dissadvantage to using assoc arrays as oppose to numeric array (that is, after the first complie)?

Ok, PHP does not compile scripts in the sense of a traditional compiled language. PHP is an interpreted language, and uses a dual pass system. First, it runs through and checks syntax, etc, and converts the source code to "opcodes", which are instructions for the interpreter. Then the interpreter runs the opcodes, and the script does whatever it was coded to do. Hence a dual pass system. At least this is my understanding of how it basically works.

Now to your question, PHP does this on every run. However, you can install an opcode cache extension, which caches the result of the 1st pass, hence saving one pass of the interpretation process on each run.

ganz_friedrich wrote:

When passing variables to functions normally, is php clever enough to know only to make a copy of the variable data when necessary (i.e. passes by reference, until some change to the variable is made)? What about foreach loops, etc. is it the same for these?

With PHP 5, it passes objects by reference and variables by copy by default. If you want to pass a variable that is not an object by reference, you have to explicitly say so in the function definition [function funcName(&$var1, $var2, ..)]

The same is true for returning references as well, object are returned by reference, but other variable types are not unless explicitly set in the function definition [function &funcName($var1, ... )]

With PHP 4, all variables, even object, are always passed by copy by default.

ganz_friedrich wrote:

Is it a lot more expensive to output concatinations of "single-quotated strings" and variables than to output everthing as one "double-quotations string" (which php checks for variables)? Or is there a faster way to output a string that needs to have variables inserted in various places? (I've heard that starting a buffer and echoing can sometimes be more efficient, but are there any other methods?)

No, double quotes will be more expensive, since PHP does not just output that data, but actually parses it. Single quotes will be less expensive. And for concatenations, for max performance, use a comma instead of a period:

 echo 'Hello ', $name, '! How are you today?';

ganz_friedrich wrote:

When making variables global within a function are they then accessible as global anywhere? Or does this just make them available to the function? (i.e. is using the global statement inside a function identical to using it outside a function?)

You'd use the global keyword in a function to access a variable that does not exist to that function, ie, it exists outside of the function. The opposite also works, meaning if it does not exist outside the function, and you then set it inside the function, then it will exist outside the function:

php > function getMe() {
php { global $me;
php { if (!isset($me)) $me = 'Set by Function';
php { return $me;
php { }
php > 
php > echo getMe();
Set by Function
php > echo $me;
Set by Function
php > 

ganz_friedrich wrote:

If mysql queries are correct, can they still fail e.g. due to mysql server overload?

How can you be certain the query won't fail? even if the query is technically correct, there are still other reasons a query might fail, so you should always check that it did not error. if you're using a db connection/abstraction layer, you can do this right in the layer so it is "hidden" from the rest of your code.

My query() method of my MySQL db connection driver looks like this for example:

class MysqlDB extends BasicDB {

//...

public function query($query) {
	if ($this->db && ($this->db !== NULL)) {
		if ($this->result = $this->db->query($query)) {
			return true;
		} else {
			$this->_addError($this->db->error, "query($query)");
		}
	} else {
		$this->_addError('Not connected to a db!', 'disconnect()');
	}

	return false;
}

//...

}

Which is used like (where $db is an instance of MysqlD😎:

$db->query('SELECT * FROM foo');

Since the error checking is being done in MysqlDB, I don't have to redo it every time I run a db query. MysqlDB takes care of that for me. 😉

[laserlight]

Single quotes will be less expensive. And for concatenations, for max performance, use a comma instead of a period

I warn that this isnt necessarily true (I've seen benchmarks that show otherwise), and that in the first place the bottlenecks may not be addressed by this sort of minor optimisation.

It is definitely true that variable interpolation is slower than concatenation, but even that has its place as the strings written may be more easily read by the programmer.

[dream_scape]

laserlight wrote:

I warn that this isnt necessarily true (I've seen benchmarks that show otherwise), and that in the first place the bottlenecks may not be addressed by this sort of minor optimisation.

Ah but the question is, have you actually tested it yourself?

Here are some quick tests I just did:

<?php

set_time_limit(0);

function benchmark($callback, $intensity = 100) {
	$start = microtime();
	for ($i=0; $i<$intensity; $i++) {
		call_user_func($callback);
	}
	$end = explode(' ', microtime());
	$start = explode(' ', $start);
	$time = number_format(($end[1] + $end[0] - ($start[1] + $start[0])), 4);
	return $time;
}

function runMultipleTests($callback, $num_tests = 100, $intensity = 100) {
	$times = array();
	for ($i=0; $i<$num_tests; $i++) {
		$times[] = benchmark($callback, $intensity);
	}
	return array_sum($times) / count($times);
}

function doubleQuote() {
	$test = md5(rand());
	$string = "A random MD5 string: $test. Thanks for playing";
	return $string;
}


function singleQuote() {
	$test = md5(rand());
	$string = 'A random MD5 string: ' . $test . '. Thanks for playing';
	return $string;
}

I ran the tests from the PHP 5 interactive console. Here are the results using runMultipleTests() to get the average time for x number of tests with y intensity:

php > // doubleQuote() AVG of 100 tests with 100 intensity
php > echo runMultipleTests('doubleQuote');
0.006136
php > echo runMultipleTests('doubleQuote');
0.006428
php >
php > // singleQuote() AVG of 100 tests with 100 intensity
php > echo runMultipleTests('singleQuote');
0.00483
php > echo runMultipleTests('singleQuote');
0.005024
php >
php > // doubleQuote() AVG of 1000 tests with 100 intensity
php > echo runMultipleTests('doubleQuote',1000);
0.0044603
php > echo runMultipleTests('doubleQuote',1000);
0.0044104
php >
php > // singleQuote() AVG of 1000 tests with 100 intensity
php > echo runMultipleTests('singleQuote',1000);
0.00346
php > echo runMultipleTests('singleQuote',1000);
0.0033877
php >
php > // doubleQuote() AVG of 1000 tests with 1000 intensity
php > echo runMultipleTests('doubleQuote',1000,1000);
0.0497277
php > echo runMultipleTests('doubleQuote',1000,1000);
0.0413407
php >
php > // singleQuote() AVG of 1000 tests with 1000 intensity
php > echo runMultipleTests('singleQuote',1000,1000);
0.0345017
php > echo runMultipleTests('singleQuote',1000,1000);
0.0334096
php > 

All together over 8,000 tests were ran with low and high intensities, and each time, single quotes wins.

There may be some cases where double quotes is faster (never say never), but I do not know of nor have ever seen any. So I think it is pretty fair and safe to say that "single quotes are faster" is a good rule of thumb.

[ganz_friedrich]

I thank you for the time you have saved me (perhaps I should have seeked out the answers, but sometimes its good to talk).

dream.scape wrote:

Now to your question, PHP does this on every run. However, you can install an opcode cache extension, which caches the result of the 1st pass, hence saving one pass of the interpretation process on each run.

Very interesting. I will definetely do that. What seems strange to me though is that when I run a script for the first time it takes considerably longer to parse than subsequent times (is this to do with the apache cache?).

dream.scape wrote:

With PHP 5, it passes objects by reference and variables by copy by default.

Now I got to start putting in those bloody '&' signs everywhere now 🙂 If you’re not going to change a variable why pass it by value???? Waste of cpu time and memory.

laserlight wrote:

I warn that this isnt necessarily true (I've seen benchmarks that show otherwise), and that in the first place the bottlenecks may not be addressed by this sort of minor optimisation.

True, but if its no more difficult to do, then why not. Also, I'm curious, why is using commas faster and how are they different - shorly they can't be equivalent to periods?

[ganz_friedrich]

RE: benchmarks

nice, and - dare I say - pretty conclusive.

You see, I was thing mainly about SQL queries where I have lists of variables seperated by commas (in sql statement), e.g.:

$result = $db->query('INSERT INTO table VALUES(\'' , $var1 , '\', \'' , $var2 , '\', ' , $var3 , '\')');

I thought that in cases like this it just might be quicker to use double quotes.

BUT even if that's the case, I guess the difference won't be significant, so as you say just use singles as a rule of thumb.

Thanks again

[Drakla]

Also passing by copy uses reference counting doesn't actually make a copy until data within the passed item is changed, so essentially it's exactly like passing by reference until you modify the parameter.

My job was programming 3d graphics engines and optimising C++ code before php, and I used to do loads of really anal optimisations with php, but you've got to realise that the optimisations in things like string handling can account for sweet F A in the actual scheme of things. You might get the same echo to interpret 10 times quicker, but that's a micro saving in a 10th of a second pool before you even hit the internet bottleneck.

Also the output buffering thing does make a massive difference when you script reaches a certain size, so always put ob_start at the top of every script, as even when it doesn't help it doesn't hurt, but when it does help it helps a lot - like seconds compared to milli seconds.

And remember to get a true benchmark of a script you need to take compile time into consideration, so just using microtime within the script if often reading a medical survey about the effects of drinking 10 tins of pop a day from Mr. Toothless McToothless from Pepsi-Co

[laserlight]

Ah but the question is, have you actually tested it yourself?

Of course I have. Sorry about the ambiguity though, what I meant is that I've seen benchmarks that show that using multiple argument echo instead of normal concatenation may actually be slower in the long run.

All together over 8,000 tests were ran with low and high intensities, and each time, single quotes wins.

That's the expected result, since your double quoted strings utilize variable interpolation instead of concatenation or multiple argument echo. Read my post again, I did say that it "is definitely true that variable interpolation is slower than concatenation".

[laserlight]

why is using commas faster and how are they different - shorly they can't be equivalent to periods?

They arent necessarily faster. In this case, the use of commas is multiple argument echo - you are passing many arguments to the echo language construct, instead of concatenating to a single argument and passing that argument to echo.

I thought that in cases like this it just might be quicker to use double quotes.

Variable interpolation is used, so it will be slower. However, my point is that the slightly slower timing here may not matter, since it improves readability.

BUT even if that's the case, I guess the difference won't be significant, so as you say just use singles as a rule of thumb.

Whether the difference is significant or not must be seen in the context of the whole script. Generally, you should look to optimise the portion of the script that constitues the bottleneck in performance. Now, it is true that bottlenecks can often be found at input/output points, but one should look to optimise from the perspective of the algorithm, rather than do some minor optimisation that could well be pre-mature.

[dream_scape]

laserlight wrote:

Generally, you should look to optimise the portion of the script that constitues the bottleneck in performance.

Well that is somewhat a moot point with web applications, where the bottleneck is almost always guaranteed to be the network. Unless the script is really poorly written or doing something unusual (and really expensive), the network will give out long before the script does.

Of course we can take the script out of the system and isolate it and examine bottlenecks within the script itself, but those will almost always be very minor in relation to the entire web stack (almost always 😉). But this doesn't mean that we shouldn't write good, clean, efficient code; but at the same time we shouldn't sacrifice readability for a very small gain.

I prefer single quotes with concatenation myself. I find them easier to read, because double quotes with interpolation, will in my opinion, end up ultimately being more difficult to read, because you will end up having to escape characters to prevent PHP from parsing them, which ruins readability, IMO.

Laser, my last reply and series of tests was in response to your "I warn that this isnt necessarily true (I've seen benchmarks that show otherwise)" statement, that was in response to my "Single quotes will be less expensive." statement. Sorry if that was not the intended meaning, but that is how it comes across in the thread 😉

[laserlight]

Well that is somewhat a moot point with web applications, where the bottleneck is almost always guaranteed to be the network. Unless the script is really poorly written or doing something unusual (and really expensive), the network will give out long before the script does.

I agree.

I prefer single quotes with concatenation myself. I find them easier to read, because double quotes with interpolation, will in my opinion, end up ultimately being more difficult to read, because you will end up having to escape characters to prevent PHP from parsing them, which ruins readability, IMO.

While I too use single quoted strings with concatenation most of the time, I think that in the case of constructing SQL queries the use of variable interpolation often helps readability - consider that single quotes are usually used as field value delimiters, for example.

Sorry if that was not the intended meaning, but that is how it comes across in the thread

I know, I wasnt careful when quoting so it is my fault.

[ganz_friedrich]

Thank you all for your help