FOR loop performance in PHP

Question

As my research leads me to believe that for loops are the fastest iteration construct in PHP... to make it clearer, which of the following do you think would be faster?

Example ONE

for ($i = 0; $i < count($myLargeArray); $i++ ) {
    echo myLargeArray[$i];
}

Example TWO

$count = count($myLargeArray);
for ($i = 0; $i < $count; $i++ ) {
    echo myLargeArray[$i];
}

My logic follows that on each iteration in example one accessing the length of myLargeArray on each iteration is more computationally expensive than accessing a simple integer value as in example two. Is that correct?

Answer 1

The first way is slower because the count() function has to be called in every iteration of the loop. The count() method itself is pretty fast, but there is still some overhead in calling the function at all. By moving it outside the loop, you're performing what is called "loop invariant code motion", or sometimes "hoisting".

There's a whole family of optimizations like this that are interesting to learn about.

Having said all that, it seldom pays to stress about this very much. In your example here, the I/O of echoing the output is probably 10 times what you save through your "optimization". And if you do anything else at all inside your loop, your optimization means less and less.

I hate to be a wet blanket, but for more than 90% of your code, performance is a non-issue. Especially when you talk about web applications, which are more than 90% I/O to begin with.

Still, when you think your code is to blame, you should:

1. Decide on the use case you need to optimize
2. Measure your code performance
3. Find the bottlenecks
4. Identify the areas you can improve and decide whether it is worth your time to improve them.
5. Make your code changes
6. Go back to step 2

You'll nearly always discover that you need to improve your caching strategies and database optimization (which is just I/O optimization by another means), instead of twiddling code.

Answer 2

Example 2. Do not count the elements every iteration.

Updated: I've just been told that the value is precomputed: nNumOfElements specifies how many values are currently stored in the array. This is also the number thatcount($array)returns.

It seems to me the function count() literally do nothing except wasting some microseconds and clock cycles (for those who know assembler).

Read here: Understanding PHP's internal array implementation (PHP's Source Code for PHP Developers - Part 4).

Perhaps you can try foreach range:

foreach (range(0, (count(array)) as $number) {
    echo $number;
}

Answer 3

The fastest construct in this case is actually the foreach loop:

foreach($myLargeArray as $element) {
    echo $element;
} 

The foreach() is also nice in that it'll always terminate, whereas a typo could leave you with an infinite loop when you use for().

Answer 4

So I decided to actually quantify a few things, in the interest of getting some real numbers. Here is the baseline code, a loop which builds a big array of 100000 integers.

$x = array();
for ($idx=0; $idx<100000; $idx++)
    $x[] = $idx;

Average time to execute: 85 ms. That includes the time to launch PHP, parse the program, run it, and exit. Now, I add another loop that iterates through the array:

for ($idx=0; $idx<count($x); $idx++) { 
    ;
}

Average time to execute: 105 ms. When you subtract the 85 ms setup time, you can see it takes only 20 ms to iterate through a 100,000 member array.

Now we add the loop invariant code motion:

$m = count($x);
for($idx=0; $idx<$m; $idx++) { 
    ;
}

Average time to execute: 90 ms.

On the one hand, this savings is huge. That's 5 ms loop iteration time instead of 20 ms. So you can argue that's a 75% savings!

On the other hand, it's 15 ms. Less time than most people will notice on an absurdly large array.

But this is an array that does nothing. Let's see what happens when we output some data:

$m = count($x);
for ($idx=0; $idx<$m; $idx++) { 
    echo $idx;
}

Now the execution time is 200 ms. Oh look, I only printed out the loop index. I didn't even output the contents of the array.

That's just silly. Let's change the program again to echo the contents of the array instead of just the look counter:

$m = count($x);
for ($idx=0; $idx<$m; $idx++)
    echo $x[$idx];

New execution time is 212 ms. So it took 5% longer to access and echo the array contents than just echo the loop counter.

Let's take someone's earlier suggestion and unroll the loop. I've used this to great effect in C/C++ in the past:

$m = count($x);
for ($idx=0; $idx<$m; $idx+=5) {
    echo $x[$idx];
    echo $x[$idx+1];
    echo $x[$idx+2];
    echo $x[$idx+3];
    echo $x[$idx+4];
}

Now we're talking! We're down to 206 ms. Oh wait, that's about a 3% improvement for some un-fun code. And the output looks terrible. It's just a string of numbers without whitespace or anything.

Let's get rid of the loop unrolling, and make the output a little nicer:

$m = count($x);
for ($idx=0; $idx<$m; $idx++)
    echo "{$x[$idx]}\n";

Execution time is 400 ms. Huh. That's a lot of extra time (relatively speaking) just to get some formatting. Maybe using the string substitution is costing us something. Let's try string concatenation instead:

$m = count($x);
for ($idx=0; $idx<$m; $idx++)
    echo $x[$idx] . "\n";

The new time is 390 ms. A little better. Let's try separating the numbers by a space instead of a newline:

$m = count($x);
for ($idx=0; $idx<$m; $idx++)
    echo $x[$idx] . " ";

Oh wow, we're back down to 224 ms. Right on! But what happened? Well, I'm running all this on my Unix terminal, and it is justs plain slower to output the numbers on separate lines than it is to output them all on one line that wraps.

In other words, the speed of the terminal program's scrolling has a bigger effect than anything else we did.

Answer 5

Clearly the example one is slower. The condition $i < count($myLargeArray) is evaluated every iteration, thus counting the array multiple times.

Check this and other benchmarks on http://www.phpbench.com/

Edit: they looked up on the source code, and it's precomputed.

However, processing time is wasted on those multiple function calls. That's why the performance drops. The array is "counted" multiple times.

Answer 6

The fastest loop would be to unroll the loop. Some code editors, but not any PHP editors, support this with a special macro so you don't need to copy and paste.