Performance Issues

Anon

I have been working on the phpShop project at http://www.phpshop.org. One of the tasks that I was recently working on was to go through and streamline the code and look for any performance bottlenecks that might be there.

Well, we found the bottleneck in performance and it seems that there is essentially nothing we can do to make it better. This is the problem:

Each time the parser loads (i.e. index.php3) it has to load all of the class and function files into memory. It does this by reading each file, checking syntax and then of course saving things in memory until they are called; if ever. After several tests we found that even if we have one huge file with all the classes and functions in it, this portion of processing consumes the most resources.

We originally thought we would have to focus on the database and making it faster through the use of indexing, etc. Then we thought that maybe the include's and require's were slowing it down. But no, the time killer is simply loading the class and function libraries into memory; even if your entire PHP application and all its functions and classes are in index.php3.

We even tried using class and function libraries that were not of our own making. There too we see that simply loading them into memory is, well, slow. One thing to note is that we saw a narrow increase in performance when loading functions versus loading classes. But the increase in performance is so small that it is almost a non-issue. The bottom line is that this bottleneck is a PHP related issue. The more code you write and include in your PHP application, the slower it gets, simply by the fact that it needs to read more code on every load.

I am posting these notes in the hope that someone out there has run into this and possibly can recommend a solution. However, after some intense review of the performance of phpShop, the bottom line is that over 75% of the processing time on each page load is consumed by the loading of the classes and functions. That's the bottleneck that we are up against. The only solution we have so far is to make sure our hardware is really fast, especially the hard drive. I am curious to know how other PHP projects have dealt with this issue.

Are we simply writing an application that is too big? What do you think??

Anon

over 75% of the processing time on each
page load is consumed by the loading of the
classes and functions

Don't load all of the functions and classes unless you need them.

include('') will work inside a if block

if (we need to load the output stuff)
{
include ('output_stuff.php')
}
else
{

we didn't load the output stuff, so there's no overhead from it.

}

Anon

Thanks Alister, that's a fair suggestion. But let me pose this another way. Say you have 100 functions defined and you know that you need to use all 100 functions. Better yet, even if you did not need to use all 100 functions directly. Let's say you only use 20 of them. However, the 20 functions you need call 50 other functions from within them. Or maybe you don't know what function uses which other function. How would you then decide which functions to include and what to base the include on? You see it becomes more complex as you go through the paces of figuring out what to include and when, especially when you are referring to function libraries. If we were only dealing with "output stuff" then it would not be so complex; we could include what we need when we need to display it.

I must make sure I point out that performance is not slow. What we have found is that if we were to say "where would there be room for improvement?", then we would have to point to this bottleneck.

I realize that if you only load what you need you reduce your overhead. I think that is obvious and goes without saying.

That said, when we load what we actually need, we still see this performance issue when looking at the page load times.

I imagine that the Zend Cache will resolve this issue, but I was hoping that either:

a. I am helping others by pointing out this issue so that they will code in as efficient a manner as possible; avoiding extra lines where not needed.

b. Maybe others have found some way to cache a function library so that you do not need to load and parse it on every page load. (This is what the Zend Cache is supposed to do, I imagine).