There are probably more than a few naive programmers who would read results like this and start to avoid these constructs in their own code for performance reasons. These are the same kinds of people obsessing over a few single or double quotes, who eschew “slow” objects in favor of switch statements that are many times slower than the polymorphic method calls they are trying to avoid.

But, that’s not the end of the story. Larry ran his benchmarks using 2,000,000 iterations. The N really matters here. Sure, iterators are slower than arrays, but you aren’t going to be iterating over two million things. I tend to fetch my database records in lots of 25 or 50. You aren’t going to be making two million invocations of __call. But how many will you make? Under what value of N does the performance of these techniques cease to matter? Is it ten, one hundred, one thousand, or ten thousand? You may be surprised at how few calls your program actually does and how little impact it has on performance.

As Wez and Travis point out in their comments, profiling is the way to find out the potential impact and to discover your true N.

Paul M. Jones has a good example of what I’m talking about. There, call_user_func_array appears to be a bottleneck, but it turns out that its the function being called, htmlspecialchars, not the calling process that consumes the balance of the time. In that case, the function was “only” called 300 times. I find that order of magnitude to be fairly typical. Something to be aware of, perhaps, but not something to obsess over.

I wrote about web page loading performance a while ago, when I linked to Dave Hyatt’s most excellent explanation of the issues involved with testing page load speed. In fact the Safari browser blog endorses Aaron Hopkins article and mentions how to measure page loading times in Safari using the debug menu.

On the Mozillia front, the Tamper Data extension generates some amazing graphs of when elements on a page load and how long it takes.

On the topic of sending less data, the Yahoo! User Interface Blog weighs in on page waits with a discussion of javascript minimization versus compression. They also briefly cover the YUI decision to serve components a la carte, rather than in an aggregated file.

Cal Henderson of Flickr also takes up this topic in serving JavaScript fast. He goes into more depth about the issue of a la carte external objects versus aggregated external objects as well as covering compression and caching issues with examples in PHP.

From the PHP perspective, Michael J. Radwin and Rasmus Lerdorf have covered web application performance issues in conference talks.

Are your web pages cacheable or not?

On the home front, this is my first post on this blog since I’ve installed wp-cache2 and upgraded to eAccelerator 0.9.5. And my first post since my fishing vacation, too

I’ve also been impressed with the new upgrade notes for 5.1. Good job there, too.

I’ve read over the whole thing and I like what I see. One thing did jump out at me.

We also discussed whether we should even allow Unicode mode to be turned off as current micro benchmarks show that the Unicode implementations of some of the string functions are up to 300% slower, and whole applications up to 25% slower. Disallowing Unicode mode to be turned off is expected to slow down the adoption of PHP 6 too as many ISPs would be reluctant to install a version that immediately slows down the applications of their users.

I am definitely not familiar with all the issues involved, but wouldn’t this make it hard to write general purpose PHP applications? Programs would have to check whether unicode was on or off? Wouldn’t that checking be slow and complicated, too?

I think its great to discuss ways to improve adoption of PHP 6 so far ahead. It looks like APC will be included. I think thats great news on the adoption front.

I wonder, though, if anyone has gone and asked hosting companies what features they might like to see in PHP 6? I also wonder if it would be helpful to have two upgrade guides: one for programmers and one for hosts. Perhaps even a separate Hosting PHP Applications section as part of the PHP manual. (With things like “How do I find out which PHP script sent out this spam?”)

PHP hosting concerns are not always the same as PHP programmer concerns. Hosts are important to the adoption of PHP and throwing them some love can only be a good thing for the platform as a whole.

It comes down to the fact that allowing references to be taken of $this can lead to unexpected values for $this later on. ($this re-assigned) However, it does not appear that a good solution exists:

Given the choice between: (A) doing nothing but leaving room for confusion, (B) taking away the ability to create references, or (C) checking assignments for references to $this(read: slow); The current decision is to go with (A).

The cause of the problems were a result of diverging away from strategy A and a little bit into strategy B. I’m still working on compiling 5.1rc3, so i’m not yet sure how this was actually resolved. I wouldn’t feel bad about a warning when this occurred. However, I think a fatal error is absolutely wrong here. I do feel confident this will get resolved in an acceptable manner because I’m fairly sure that unless it becomes illegal to pass $this to a function by reference that there will always be a workaround for making code compatible with PHP 4 regarding $this. Thanks to everyone who looked in to it.

In the meantime, Derrick Rethans made an article he wrote for php|architect explaining PHP References available. You should read this article. I had to print it to follow it, but I learned something that I did not know. I did not know that PHP uses a copy on write semantic for normal variables. The one question that I wish the article had covered was how objects get automatically passed by reference in PHP 5.

The article debunks some myths about using references for performance. I experimented with this a bit when PHP 4 first came out, but quickly gave up on using references for optimization. I ended up with too many mysterious bugs to track down from “magically connected” variables. I finally ended with some fairly limited rules for using references. I avoid them in all cases except when passing values to functions by reference and for variables that held objects, in which case I use them always. When I want mystery i’ll go to the library, thank you. I don’t need it in my software.

I’ve been looking at the changes necessary for the php 4.4/5.0.5 update. I wrote a little scanner program to help locate suspicious return statements. (I’m far from E_STRICT anyway.) But, I have no programatic help for finding “Only variables can be passed by reference” errors except to actually trigger the error.

I’ve been a little bit frustrated about getting over the compatibility hump with 4.4/5.0.5/5.1rc3. But that seems like nothing compared to the ingrate who emailed Derrick fan mail. This dude needs to get a grip.

I don’t think the update was a mistake at all. Like I said earlier, I’ll take my PHP without mysterious bugs, please. Rather, I think the mistake here was in not understanding the backward compatibility issues. I went back and read some of the orginal discussion about this update. What strikes me was that binary compatibility was discussed, but no-one seemed that excited about the backward compatibility issues at the code level.

So a mistake was made. These things happen. Steps have been taken to ensure that something like this is less likely happen again. Derrick’s fan needs to get over it and move on.

Along these lines, It seems like with so many projects using automated testing that there should be a process for projects with automated test suites to package them up and donate them to an automated backward compatibility lab.

In PHP multi-threaded programming using ticks is rather primitive, to put it politely. I couldn’t find any way to share data between multiple invocations of the script, without resorting to file or SQL. I missed saving in servlet context and singletons (evil!).

I however kept looking for a uber-global which will allow me to persist data across sessions.

I couldn’t find simple way to cache data in PHP. File or DB based caching was unattractive to me.

This pretty much sums up the fundamental difference. PHP shuns threads in favor of simplicity and relies on files and databases to “share data between multiple invocations of the script.” The author doesn’t make this paradigm shift and erroneously implies that PHP is not scalable. At the same time, he offers this insight into the mindset of Java programmers:

I think it is because Java think-tank wants to encourage programming with resource constraints in mind. remember Java had an Oak background, a language targeted for limited resource devices.

The sad part is that most Java developers get bogged down by such trivialities and cannot see the forest for trees. I know, I know you are an exception.

Most of the time you hear Java programmers thinking of scalability and performance when his PHP counterparts are happily coding away in a world with unlimited resources (they think). Unfortunately Java developers as a group tend to get bogged down with resource conservation mindset.

There is a name for this. It is called premature optimization. And it often leads to code that is slower and less scalable. Scalable applications can be written in PHP. One just uses a different set of patterns to write them in PHP than in Java.

Speaking of mindset…

Overall a large part of the difference is in the mindset of a Java and PHP developer. How do you perform SQL queries in PHP? You just create a SQL statement string in code concatenating proper parameters as necessary.

Tell that to a Java programmers worth his salt. If he doesn’t half-die in shock, I would be surprised. … At the very least he must stow away his SQL code in a separate class and use the functionality by invoking methods in that object.

PHP pitches a large tent. There are many amateur and professional programmers using PHP. I don’t know many of the professionals using this technique. Most people I know are using a data base abstraction library, such as PEAR:DB, PEAR:MDB2, or ADODB, Creole or perhaps even PDO.

The interesting thing is that some of the most popular PHP applications are not the ones that I would point to and tell people “this is a good example of programming in PHP.” I won’t name names, but I would hate for people to form their opinions about PHP solely on the design of these applications.

I got my first paid full time programming job over the summer when I was 17 and worked as a full time professional programmer during all but two years of my college career. Eventually I came to a realization that caused me to change my major from computer science to business. That realization was that project success has far more to do with how closely your software meets requirements than how technically advanced it is. I have personally witnessed far more “high architecture” projects that never finished or met the users needs than “low architecture” projects that couldn’t be made to scale when necessary.

That is why software built by their users, such as many visible PHP projects are, can be very successful. They do exactly what the users would want them to do. Then we professional programmers look under the hood and and turn a little green. However, sometimes worse is better.

The reasoning behind this speedup is that when the PHP compiler encounters a string constant beginning with a double quote, the string itself must be parsed and special characters (such as $, \ and {) have special meanings. By contrast, if a string constant begins with a single quote, only the backslash has a special meaning, and therefore PHP doesn’t have to worry about replacing variables and expressions embedded in the string.

This line of thought is flawed for two reasons.

First, PHP uses flex to tokenize the php source code. Flex is a table driven lexer. It doesn’t necessarily follow that having more characters with special meaning makes flex slower if you don’t actually use those characters.

Second, the original benchmark doesn’t actually measure parsing time. Like all microtime() based benchmarks, the first access of microtime() doesn’t happen until the php file is completely parsed and converted into opcodes. Additionally, it executed each literal inside a 10,000 iteration loop. Thats 1 time to parse it and 10,000 times to execute it.

I put together a different benchmark that does measure parsing time. It consists of two files

 
<?php echo 'very long string'; ?>
 

 
<?php echo "very long string"; ?>
 

The very long string I used was the text of the US constitution: 27,787 bytes. I measured using ab, which includes parsing time. My results:

single quotes: 27.59 ms
double quotes: 27.74 ms

Hardly earth-shattering. Single quotes was consistently faster, but by the same minor margin. This is with a 27k literal string. My guess is that you will never have enough literals in a typical PHP program for any parsing performance differential to matter.

Is there an execution differential? Do both of these constructs generate the same opcodes? I tried to check it out using Vld or parsekit but I can’t get either of these to work in my development environment (OS X). Perhaps someone will reply in a comment with the opcodes for the previous two programs and settle the question.

There doesn’t seem to be much if any difference between single and double quotes for an identical string. A more interesting question would be what happens when the strings aren’t identical. Consider the following three examples:

 
<?php echo "Answer: $answer!"; ?>
 

 
<?php echo 'Answer: ', $answer, '!'; ?>
 

 
<?php echo 'Answer: ' . $answer . '!'; ?>
 

 
Answer: <?php echo $answer; ?>!
 

My gut feeling is that concatenation is slower because of the ability of the output buffer to allocate memory in big chunks rather than little chunks. Other than that, I honestly don’t think it makes a difference, but I would love to compare the opcodes for each of these examples.

I hope that more information will come out about this. It would be nice to have another large scale case study alongside the Yahoo talks: Large Scale PHP, One year of PHP at Yahoo, and Making the case for PHP at Yahoo.

Another interesting case study is the Gaia Online discussion board. One of the largest forums on the net, on a recent check, it claims to have 70 million messages online with roughly 9,000 simultaneous users, and 750,000 registered users. The sitepoint post that brought this to my attention claims they are getting over 700,000 new posts per day. All of this running on a modified version of open source phpBB. Here is an interview with the board owner and founder.

The thread that talks about the modifications to phpBB to support Gaia Online’s volume is very interesting. It focuses mostly on query optimization. Not surprising in light of the previous discussion on PHP’s shared nothing architecture. If PHP encourages moving concurrency management to the database, then application scalability is going to become a matter of database scalability.

Switching from scalability to performance, John Lim talks about his experiences optimizing PHP code using xdebug. His article makes me want to check out xdebug, but I have too much on my plate right now to even risk getting near my PHP configuration. I am hoping that I will have time to do this before the upcoming WACT release.