PHP. Оптимизация программ на PHP

• Выносите $переменные из "текстовых строк" - ускорение 25-40%
• Короткие переменные не более 7 символов - ускорение 15%
• Тормозят ли массивы в PHP? Вернее, как именно. Ускорение 40%
• Выносите многомерные массивы из "текстовых строк" - ускорение 25-30%
• Регулярные выражения: PHP(POSIX) vs Perl. Ускорение 60-200%
• Циклы: for, foreach, while, count/sizeof() - ускорение 15%-30%
• Для чтения файла file() быстрее, чем fopen+цикл - ускорение 40%

Выносите $переменные из "текстовых строк" - ускорение 25-40%

1. {$x="test".$test;    }
2. {$x="test $test";    }
3. {$x="test";$x.=$test;}

Итак, никогда не пишите $a="$b", ибо это затормозит программу (в этой строке) на 40%.

Однако, если у вас большая строка, где много текста и переменных, различия в скорости уменьшаются, т.к. общие затраты на парсинг становятся намного больше, чем разные по эффективности команды. Но почему бы и не увеличить скорость программы (строк присваивания) почти на четверть таким простым методом?

1. {$x="test ".$test." test ".$test." test ".$test;                }
2. {$x="test $test test $test test $test";                         }
3. {$x="test ";$x.=$test;$x="test ";$x.=$test;$x="test ";$x.=$test;}

Короткие переменные не более 7 символов - ускорение 15%

1. {$x=1;}
2. {$x2=1;}
3. {$x03=1;}
4. {$x004=1;}
5. {$x0005=1;}
6. {$x00006=1;}
7. {$x000007=1;}
8. {$x0000008=1;}
9. {$x000000010=1;}
10. {$x00000000012=1;}
11. {$x0000000000014=1;}
12. {$x000000000000016=1;}
13. {$x0000000000000000000000000000032=1;}

Переменные от 32 символов могут тормознуть программу почти на половину.

Но если заполнять пробелами (" "), чтобы все строки "$x=1; ..." по длине занимали одно и тоже расстояние, то получается вот что:

1. {$x=1;                                   }
2. {$x2=1;                                  }
3. {$x03=1;                                 }
4. {$x004=1;                                }
5. {$x0005=1;                               }
6. {$x00006=1;                              }
7. {$x000007=1;                             }
8. {$x0000008=1;                            }
9. {$x000000010=1;                          }
10. {$x00000000012=1;                        }
11. {$x0000000000014=1;                      }
12. {$x000000000000016=1;                    }
13. {$x0000000000000000000000000000032=1;    }

Уж как комментировать тест переменной из одного символа (на 2% медленне самого быстрого) - не знаю... Наверно, тесты имеют большую погрешность. Предлагаю кому-нибудь запустить тест на час (исходники теста внизу страницы).

Одно ясно - при длине переменных в 8 и более символов происходит резкое снижение производительности, до 15%! А команд, включающих названия переменных, очень много. Еще один менее резкий скачек на переменных с именем 16 символов в длину и более. А в остальных случаях - чем больше, тем дольше, весьма линейная зависимость.

Вывод - не используйте переменны из 8 и более символов, выиграете 15% скорости (вернее, сэкономите).

Тормозят ли массивы в PHP? Вернее, как именно. Ускорение 40%.

1. {$test[0000]=1;$test[0001]=1;$test[0002]=1;$test[0003]=1;$test[0004]=1;     }
2. {$test[1000]=1;$test[1001]=1;$test[1002]=1;$test[1003]=1;$test[1004]=1;     }
3. {$test["aa"]=1;$test["bb"]=1;$test["cc"]=1;$test["dd"]=1;$test["ee"]=1;     }
4. {$test[aa]=1;  $test[bb]=1;  $test[cc]=1;  $test[dd]=1;  $test[ee]=1;       }
5. {$test[0][0]=1;$test[0][1]=1;$test[0][2]=1;$test[0][3]=1;$test[0][4]=1;     }
6. {$test[2][1]=1;$test[3][8]=1;$test[4][9]=1;$test[33][99]=1;$test[123][99]=1;}
7. {$test[a][b]=1;$test[x][y]=1;$test[d][c]=1;$test[a][s]=1;$test[b][n]=1;     }

Что тут можно комментировать.. все очевидно. Доступ к элементу одномерного ассоциативного массива по имени, не заключенному в кавычки, тормозит процесс на треть (относительно того же примера, но в кавычках). А вот в двухмерном массиве программа работает медленне аж в 2.5 раза! После такого теста хочешь не хочешь, а в любой программе пожертвуешь удобством - обращение к элементам массива по имени без кавычек.

Выносите многомерные массивы из "текстовых строк" - ускорение 25-30%. Одномерные можно не выносить.

1. {$x="test ".$myarray["name"]["second"][1]." test";       }
2. {$x="test {$myarray[name][second][1]} test";             }
3. {$x="test ";$x.=$myarray["name"]["second"][1];$x=" test";}

Тот же пример с ассоциативным 3-х мерным массивом, но с обращением к элементу по его индексному номеру:

1. {$x="test ".$myarray[3][2][0]." test";       }
2. {$x="test {$myarray[3][2][0]} test";         }
3. {$x="test ";$x.=$myarray[3][2][0];$x=" test";}

Разница в 1 и 2 вариантах очень мала. Это говорит, что потери на не эффективное использование кавычек не слишком большое, чем доступ к массивам (см. тесты в первой главе).

1. {$x="test".$myarray["test"]."test";}
2. {$x="test$myarray[test]test";      }
3. {$x="test{$myarray[test]}test";    }

А теперь, на основании всех трех тестов, однозначный вывод: использовать фигурные скобки для обозначения границ имени элемента многомерного массива НЕЛЬЗЯ. Это сильно снижает скорость работы - 25-30% (в третьем варианте от простого добавления скобок скорость понизилась на четверть). Не использовать скобки нельзя. Следовательно, единственный способ не терять 30% скорости - выносить многомерные массивы из скобок.

Такой же тест, но для одномерных:

1. {$x="test".$myarray["test"]."test".$myarray["test"]."test".$myarray["test"];   }
2. {$x="test$myarray[test]testtest$myarray[test]testtest$myarray[test]test";      }
3. {$x="test{$myarray[test]}testtest{$myarray[test]}testtest{$myarray[test]}test";}

Сравнивая два последних теста очевидно, что одномерные массивы можно и не выносить, потери всего 3-4% ( а вот на простых переменных - потери 25-40%!).

Регулярные выражения: PHP(POSIX) vs Perl.

Хочу заранее предупредить любителей Перла, чтобы не радовались: хоть перловые реги и круче пхпышных, только ничто и никто не мешает использовать в PHP перловые реги! Наверно, потому их и встроили в PHP, что уж больно тормоза большие... :-)

Итак, простейший текст. Поиск простого выражения в тексте, который состоит из многократного повторения данной статьи (получается размер переменной $text в 3 Мб).

Тест вызывает всего 1 раз, ибо реги имеют встроенное средство для кеширования результатов компиляции. Т.е. перед запуском проиходит компиляции, а повторные реги не компилируются. Это особенности регулярных выражений. Разные языки программирования в состоянии хранить разное число откомпилированных выражений, что вызывались (в порядке вызова в программе). И в данном тесте как раз нет эффекта от компиляции, т.к. функция вызывается всего один раз.

1. {eregi("МаС+иВ",$text);}
2. {preg_match("/МаС+иВ/im",$text);}

1. {eregi("(ма[a-zа-я]{1,20})",$text);}
2. {preg_match("/(ма[a-zа-я]{1,20})/im",$text);}

Пример для другого выражения и 30-мегабайтного текста (все те же повторы статьи, что вы сейчас читаете):

1. {eregi("(ма[a-zа-я]{1,20})",$text);}
2. {preg_match("/(ма[a-zа-я]{1,20})/im",$text);}

Я еще писал штук пять разных выражений, но тенденция не меняется. Скорость может меняться, но Pelr обгоняет POSIX минимум на половину. Этого достаточно, чтобы похоронить функции регулярных выражений от PHP (POSIX). Для всех функций есть аналогичные Perl-ориентированные (все они встроены в PHP).

Далее один очень показательный пример на этой же статье (увеличение до 28Мб). Пример ищет в тексте e-mail. По свойству "жадности" регулярных выражений будет найден самый большой и наболее близкий к левому краю адрес.

Этот пример огорчит любителей перла. Приятно их огорчать :-)

1. {eregi("([a-z_-]+@([a-z][a-z-]*\.)+([a-z]{2}|com|mil|org|net|gov|edu|arpa|info|biz))",$text);}
2. {preg_match("/([a-z_-]+@([a-z][a-z-]*\.)+([a-z]{2}|com|mil|org|net|gov|edu|arpa|info|biz))/im",$text);}

Из одного теста делать вывод сложно, но, видимо, чем сложнее регулярное выражение, тем больше POSIX отстает от Perl.

А теперь тот же пример, но только в статье (увеличение до 28Мб) нет НИ ОДНОГО символа "@" (я специально сделал копию статьи и стер эти символы):

1. {eregi("([a-z_-]+@([a-z][a-z-]*\.)+([a-z]{2}|com|mil|org|net|gov|edu|arpa|info|biz))",$text,$ok); echo $ok[1];}
2. {preg_match("/([a-z_-]+@([a-z][a-z-]*\.)+([a-z]{2}|com|mil|org|net|gov|edu|arpa|info|biz))/im",$text,$ok); echo $ok[1];}

Что мы видим?.. Ничто в этом мире не совершенно. Конечно, это очень не оптимизированное выражение для поиска email'ов, но всё же все те, кто кричал мне в форуме "ereg - отстой", на этом и похожих примерах могут отдыхать. Бывает же, что в тексте нет ни одной собачки :-)

Итак, вывод о скорости с примерами был дан выше. Вывод однозначный - надо использовать Perl-ориентированные регулярные выражения. В начеле главы я упоминал о кешировании откомпилированных копий регов. Если в программе одно и тоже выражение встречается неоднократно, производительность может отличаться не просто многократно, а в 10-100-1000 раз!

Селдующий пример вызывается 200 раз подряд над текстом в 250Кб:

1. {eregi("МаС+иВ",$text);}
2. {preg_match("/МаС+иВ/im",$text);}

Что такое кеш - знают все. Видимо именно с кешем в PHP проблеммы... Кстати, ради примера, отключите в BIOS е вашего комптьютера кеш процессора и попробуйте загрузить Windows 2000... Не дождетесь! (Кажется, их называют L1 и L2 - два разных кеша для кода и данных первого и второго уровня, какой то из них можно отключить.)

Циклы: for, foreach, while, count/sizeof() - ускорение 15%-30%

1. {$x=0; foreach($test as $n)                          { $x=sprintf("test%08i",$i);        }}
2. {$x=0; for ($it=0; $it<100000; $it++)                { $x=sprintf("test%08i",$i);        }}
3. {$x=0; $it=0; while($it<100000)                      { $x=sprintf("test%08i",$i); $it++; }}
4. {$x=0; for ($it=0; $it<count($test); $it++)          { $x=sprintf("test%08i",$i);        }}
5. {$x=0; $it=0; while($it<count($test))                { $x=sprintf("test%08i",$i); $it++; }}
6. {$x=0; $co=count($test); for ($it=0; $it<$co; $it++) { $x=sprintf("test%08i",$i);        }}
7. {$x=0; $co=count($test); $it=0; while($it<$co)       { $x=sprintf("test%08i",$i); $it++; }}

Почему sprintf, а не реальное echo? echo использовать нельзя, т.к. от него будет немерянный буфер (OUTPUT в браузер или консоль).

Теперь о деле. Бесспорный вывод - использование foreach сильно тормозит дело, а между for и while большой разницы нет. (На голом тесте for/while/foreach {..} тормоза foreach - 30%). Это не удивительно, т.к. foreach делает копию массива, на что тратиться масса времени (хотя это только слухи).

Вывод с count() не столь очевиден, потому что от разного текста в цикле % тормознутости от самого быстрого варианта резко возрастает... Я взял цикл с небольшой нагрузкой - проход по огромному массиву $test + форматирование функцией sprintf. Как видите, варинты с count() и заменяющей эту функцию перемнной $co различаются на 10% по скорости между собой (не смотрите на варинант с константой в 100000, заранее знать кол-во элементов невозможно).

Вывод о не ассоциативных массивах: 1) foreach существенно замедляет работу 2) использование count() в простых циклах - замедленение 10%. Но на сложных циклах потери от лишних запусков count() будут абсолютно незаметны, так что ситуация не очевидна.

Сравнение count() и sizeof().

Судя по мануалу - это алиасы. Об этом написано на страницах самих функций и дополнительной странице "Appendex => Aliases list". Что же мы видим на массиве в 100000 элементов:

1. {$x=0; for ($it=0; $it<count($test); $it++)  { $x=sprintf("test%08i",$test[$it]);}}
2. {$x=0; for ($it=0; $it<sizeof($test); $it++) { $x=sprintf("test%08i",$test[$it]);}}

Пусть тесты будут иметь погрешности... Но результат один - count() заметно отстает по скорости от sizeof()! Хм, я бы к записи в мануале сделал приписку: "The sizeof() function is an alias for count(), but последний сильно тормозит!"

Если кол-во элементов в массиве меньше 65000 (64К), то эти функции по скорости практически не различимы. Тут вывод простой - переходим на использование sizeof(), как ускоренного алиаса count(). Это принесет свои результаты на огромных массивах.

Ассоциативные массивы: тестирование разных способов перебора

С ними наблюдается таже проблема: на разных по величине массивах разные функции эффективны, но лучше всех foreach!

Массив в 200 элементов и 1000 повторов программы:

1. {$x=0; foreach($test as $k=>$v) { $x=sprintf("%s=>%s\n",$k,$v);                                                           }}
2. {$x=0; reset($test); while (list($k, $v) = each($test)) { $x=sprintf("%s=>%s\n",$k,$v);                                   }}
3. {$x=0; $k=array_keys($test); $co=sizeof($k); for ($it=0; $it<$co; $it++) { $x=sprintf("%s=>%s\n",$k[$it],$test[$k[$it]]); }}
4. {$x=0; reset($test); while ($k=key($test)) { $x=sprintf("%s=>%s\n",$k,current($test)); next($test);                       }}

Тоже самое, но массив в 5000 элементов и 200 повторов:

Опять тоже самое, но массив в 100 000 элементов и без повторов:

Другие тесты на холостых циклах тоже показывают преимущество foreach.

Резюме:

• sizeof() лучше, чем count()
• в циклах sizeof лучше вообще заменить на переменную
• for и while практически не отличимы
• для перебора простых индексных массивов нужно использовать for или while
• для перебора ассоциативных массивов нужно использотьва foreach

Для чтения файла file() быстрее, чем fopen+цикл - ускорение 40%

   $f=fopen("1Mb_file.txt","r") or die(1);
   while($x[]=fgets($f,1000));
   fclose($f);

Аналогичные варианты

   $f=fopen("1Mb_file.txt","r") or die(1);
   while($s=fgets($f,1000)) $x[]=$s;
   fclose($f);

   $f=fopen("1Mb_file.txt","r") or die(1);
   while(!feof($f))) $x[]=fgets($f,1000);
   fclose($f);

работают еще медленнее (во втором случае лишняя функция feof() заметно снижает скорость). Тот же тест, но на 15Мб файле (100 000 строк по 150 байт) показывает разницу в 50%, в пользу file(). Тест проводился так, чтобы исключить фоновый своппинг во время работы из-за предшествующих команд создания/чтения таких больших файлов. Подсчитать тоже самое на очень маленьких файлах в 1-2 Кб не представляется возможным, т.к. операцию чтения нельзя повторять в течении одного теста, операции чтения будут кешироваться...