

40 Tips for optimizing your php Code - raindoll
http://reinholdweber.com/?p=3

======
some
> 1\. If a method can be static, declare it static. Speed improvement is by a
> factor of 4.

Wow!

    
    
     function Prime1() { ...calc one million prime numbers...}
    
     static function Prime2() { ...calc one million prime numbers...}
    

Prime2() will calculate the prime numbers 4 times faster then Prime1()? Cool.

------
jbyers
These range from sensible to utterly useless [1,2,3].

I'd say forget all of this and focus on being a productive developer, building
something people want, and ruthlessly avoiding premature optimization. When
your application is slow, measure it to find out why, then fix it, and repeat.

1\. Let's take #2, "echo is faster than print" - Seriously, is this what we
should be worrying about? I can't detect a difference in PHP 5.2.4 across
100,000 echos/prints, so it must not be very big.

2\. ++i vs i++ to squeeze out 1 fewer opcode?

3\. Using isset($foo{5}) vs a strlen check? I pity the next programmer who has
to read and understand the purpose of this code.

------
some
> Set the maxvalue for your for-loops before and not in the loop.

What does this mean?

~~~
raindoll
it means that this:

$maxvalue = 100/10; for($i=0; $i<$maxvalue; $i++){ // Some code }

is much faster than this:

for($i=0; $i<100/10; $i++){ // Some code }

because the value is calculated once instead of ten times.

~~~
ratsbane
That's not necessarily true. If the compiler is smart enough it won't
recalculate the value of a numeric expression which doesn't contain any
variables. On the other hand, dereferencing a variable isn't without cost. Of
course, in most cases you'd be dereferencing variables anyway in the test
clause, so the original idea, compute loop limits before entering the loop, is
correct.:

mbp:~/test doug$ time php -r 'for ($i=1; $i<100000000/10; $i++) {$x++;};'

    
    
      real    0m5.930s
      user    0m5.867s
      sys     0m0.026s
    
      mbp:~/test doug$ time php -r '$maxval=100000000/10; for ($i=1; $i<$maxval; $i++) {$x++;};'
    
      real    0m6.999s
      user    0m6.907s
      sys     0m0.029s
    
    
    
      mbp:~/test doug$ time perl -e 'for ($i=1; $i<100000000/10; $i++) {$x++;}'
    
      real    0m2.520s
      user    0m2.496s
      sys     0m0.010s
    
      mbp:~/test doug$ time perl -e '$maxval=100000000/10; for ($i=1; $i<$maxval; $i++) {$x++;}'
    
      real    0m2.537s
      user    0m2.499s
      sys     0m0.014s
    
    
    

The results are a little different with Python (maxval1.py computes inline;
maxval2 divides in advance and uses variable inline)

    
    
      mbp:~/test doug$ time python maxval1.py
    
      real    0m2.134s
      user    0m1.761s
      sys     0m0.276s
    
      mbp:~/test doug$ time python maxval2.py
    
      real    0m1.890s
      user    0m1.588s
      sys     0m0.278s
    
    

Java shows even more of a difference (again, maxval2 sets variable in
advance):

    
    
      mbp:~/test doug$ time java maxval1
    
      real    0m0.174s
      user    0m0.116s
      sys     0m0.040s
    
      mbp:~/test doug$ time java maxval2
    
      real    0m0.531s
      user    0m0.125s
      sys     0m0.041s
    

~~~
andreyf
Does anyone have any ideas for what's happening in the Python example? Could
you post the Python code?

~~~
ratsbane
Sure... here is maxval1.py:

    
    
      for i in range(1, 100000000/10):
        pass
    
    

And here is maxval2.py:

    
    
      maxval=100000000/10
      for i in range(1, maxval):
        pass
    

~~~
andreyf
Oh, of course - range() is evaluated once in either case. It returns an array,
which is then stepped through. The time difference must have been just some
inaccuracy. I guess 'time' isn't the best command to use to test efficiency
... or maybe try adding another 0?

~~~
ratsbane
Oh, thanks. I redid it using xrange instead of range and the numbers went down
to an average (over 20 tries) of about 1.36 sec for maxval1 (which computes
endpoint within the xrange) and 1.9 sec for maxval2 (which uses variable in
xrange.)

