If the processing time of the following code is 120ms.
  for ($i=0; $i<1000000; $i++) {
    // Do nothing
  }

And the processing time of this code is 80ms.
  $i = 1000000;
  $n = (int)($i % 8); // first do a modulo
  $c = 0; // just to check the result
  
  if ($n > 0) {
    while ($n–) {
      // Do nothing
      $c++;
    }
  }
  
  $n = (int)($i / 8);
  
  if ($n > 0) {
    while ($n–) {
      // Do nothing
      $c++;
      // Do nothing
      $c++;
      // Do nothing
      $c++;
      // Do nothing
      $c++;
      // Do nothing
      $c++;
      // Do nothing
      $c++;
      // Do nothing
      $c++;
      // Do nothing
      $c++;
    }
  }
You would indeed save a third of the processing time.

But that is only on the processing time for the loop itself. The processing time of the code in the loop doesn’t change.

Lets say the following code would take about 1120ms to process (forgetting the overhead of calling time_nanosleep):
  for ($i=0; $i<1000000; $i++) {
    time_nanosleep(0, 1000); //sleep for 1ms
  }

If we would compare it to the processing time of this code:
  $i = 1000000;
  $n = (int)($i % 8); // first do a modulo
  $c = 0; // just to check the result
  
  if ($n > 0) {
    while ($n–) {
      time_nanosleep(0, 1000); //sleep 1 ms
      $c++;
    }
  }
  
  $n = (int)($i / 8);
  
  if ($n > 0) {
    while ($n–) {
      time_nanosleep(0, 1000); //sleep 1 ms
      $c++;
      time_nanosleep(0, 1000); //sleep 1 ms
      $c++;
      time_nanosleep(0, 1000); //sleep 1 ms
      $c++;
      time_nanosleep(0, 1000); //sleep 1 ms
      $c++;
      time_nanosleep(0, 1000); //sleep 1 ms
      $c++;
      time_nanosleep(0, 1000); //sleep 1 ms
      $c++;
      time_nanosleep(0, 1000); //sleep 1 ms
      $c++;
      time_nanosleep(0, 1000); //sleep 1 ms
      $c++;
    }
  }
This function would take 1080ms to process and not 750ms, saving you only 3.5%.

This is part of the point I wanted to make. Don’t take things out of context and go and benchmark them, because it won’t help you in real-life situations. A Duff’s device is a nice method of squeezing some extra performance out of code that is already optimized. But simply by using PHP that is hardly the case. If you’re you want great performance you should just program that part in C, that will probably increase the performance by an order of magnitude.

Sorry, I can’t follow you…. How do you compare 40ms on seconds, while before you take 120ms and take a third (40ms)?

A third of a few seconds (say 6) is still (2) seconds gain.

Instead of:

for ($i = 1933999; $i > 0; $i–) {
  // do some stuff
}

You could use a Duff’s device and save some seconds. I benchmarked it with real functions and gained a third in speed.

So, if it doesn’t seems worth the trouble… don’t use it.

- Unomi -

< ?php
  $time = microtime(true);
  for ($i=0; $i<1000000; $i++) {
    // Do nothing
  }
  echo (microtime(true) - $time) * 1000, ' ms';
?>

This script will take about 120ms to run on my computer. A third of that is 40ms. If I replace //Do nothing with something simple as $s .= $i;, the script will take about 500ms.

A script that actually has a function will probably take a few seconds to process a million items. Saving 40ms than hardly seems worth the trouble.

Do a for loop with an iterator backwards ($i++ will be $i–), it’s slightly faster. If you’re desperate about your loop, use a Duff’s device or a revision of it. Like this:

$i = 1933999; // any amount
$n = (int)($i % 8); // first do a modulo
$c = 0; // just to check the result

if ($n > 0) {
  while ($n–) {
    //do some stuff
    $c++;
  }
}

$n = (int)($i / 8);

if ($n > 0) {
  while ($n–) {
    //do some stuff
    $c++;
    //do some stuff
    $c++;
    //do some stuff
    $c++;
    //do some stuff
    $c++;
    //do some stuff
    $c++;
    //do some stuff
    $c++;
    //do some stuff
    $c++;
    //do some stuff
    $c++;
  }
}

It is much more code than usual, but it works like 1/3 faster than a normal loop. You have to do the last stuff 8 times, but only if $n > 0; The first does a modulo, so everything not dividable by 8 comes first. The remaining comes after that.

You could even do query results this way, but I won’t go into that.

For people saying it is less readable, I agree. But you could get used to it and take this method for faster results.

- Unomi -

You are talking about a 1 million record loop. That is exactly the kind of big loops I’m taking about. Within such a loop there should be as little as possible. No big if or switch statements, no calling all kind of abstract functions and most definitely no using expensive stuff like create_function(). If you’re able to do that without use create_function, good! use that. However, if I have the choice between putting lots of stuff in the loop and having performance problems, or preparing for the loop and using create_function and have good performance, I choose the latter.

The fact that code like this might end up anywhere is not really a valid statement. You’ll use this is at a point where you’re going to loop through tens of thousands (or more) rows, It is highly unlikely that that code is in yet another big loop.

Last, the example given, of creating an HTML table, is quite reusable. It works for any result set, simply pass data and meta-data.

“You really should avoid using this(create_function) as well as you should avoid using eval(). Not only will there be a performance decrease but can it lead to obfuscation and bad coding habits. There is almost always an alternative solution to self modifying code.”

“Beware when using anonymous functions in PHP as you would in languages like Python, Ruby, Lisp or Javascript. As was stated previously, the allocated memory is never released; they are not objects in PHP — they are just dynamically named global functions — so they don’t have scope and are not subject to garbage collection.

So, if you’re developing anything remotely reusable (OO or otherwise), I would avoid them like the plague. They’re slow, inefficient and there’s no telling if your implementation will end up in a large loop. Mine ended up in an iteration over ~1 million records and quickly exhasted my 500MB-per-process limit”

also check out http://blog.libssh2.org/index.php?/archives/60-create_function-is-not-your-friend.html

regards