admin

Учимся использовать screen

Гру 292011

Учимся использовать screen

Вы залогинились на ваш удаленный сервер через ssh, радостно стучите по клавиатуре, делая свои какие-то админские дела и опа! Символы перестали печатться и вывалилось то самое сообщение, которое, порой, вызывает непреодолимое желание разбить клавиатуру. Connection closed. Знакомая ситуация? Да-да, ваша сессия только что аварийно оборвалась и все придется делать заново… Этого можно избежать, если использовать screen. Он не только позволит сохранить вашу сессию в целости и сохранности, но еще и позволит держать открытыми несколько сессий в одном окошке терминала

Что такое screen?
Сначала посмотрим man-страницу: “Screen – это полноэкранный оконный менеджер, который позволяет разделить физический терминал между несколькими независимыми процессами (обычно интерактивными облочками)”.
У screen есть несколько отличительных особенностей, которые могут сильно помочь при выполнении задач на удаленных серверах через ssh. Я расскажу о трех, самых часто используемых мной фичах: многооконность, логирование и сессии. За более подробными деталями придется обратиться к man-странице.

Установка screen
Скорее всего, screen уже есть в вашей системе. Проверить это можно командой

$ which screen

Если which не дал результатов, то установите screen при помощи пакетного менеджера вашей системы. На моих серверах, в основном, CentOS и Debian, поэтому я ставлю screen так:

# yum install screen (для CentOS)
# apt-get install screen (для Debian)

Попадается и FreeBSD, в этом случае я использую порты:

# cd /usr/ports/sysutils/screen
make install clean

Использование screen
Screen запускается из командной строки также, как и любое приложение 🙂

$ screen

Вы можете получить сообщение о том, что screen запущен, а можете и не получить… Зависит от вашей системы. Если вы не получили сообщения, то вы можете подумать, что ничего не произошло. Однако это не так. Вы уже внутри терминала, запущенного в screen. Это нормальный полнофункциональный шелл, за исключением нескольких специальных команд. Screen использует клавиатурную комбинацию Ctrl+A для подачи команд терминалам внутри себя. Попробуйте нажать Ctrl+A, а затем ?
Вы увидите примерно следующее:

Screen key bindings, page 1 of 2.

Command key: ^A Literal ^A: a

break ^B b lockscreen ^X x reset Z
clear C log H screen ^C c
colon : login L select ” ‘
copy ^[ [ meta a silence _
detach ^D d monitor M split S
digraph ^V next ^@ ^N sp n suspend ^Z z
displays * number N time ^T t
fit F only Q title A
flow ^F f other ^A vbell ^G
focus ^I pow_break B version v
help ? pow_detach D width W
history { } prev ^P p ^? windows ^W w
info i readbuf < wrap ^R r
kill K redisplay ^L l writebuf >
lastmsg ^M m remove X xoff ^S s
license , removebuf = xon ^Q q
[Press Space for next page; Return to end.]

Screen воспринимает командные клавиатурные комбинации после нажатия Ctrl+A. Вы можете изменить это поведение при помощи конфиг-файла $HOME/.screenrc

Многооконность
Screen, как и большинство оконных менеджеров, поддерживает работу с несколькими окнами. Это очень удобно для выполнения параллельных задач без открытия новых ssh-сессий. Например, у меня постоянно открыто четыре или пять сессий с несколькими задачами в каждой. Раньше мне бы пришлось открыть порядка 15 терминалов, логинов, сессий.. Утомительно, не так ли? Эти неудобства полностью решает screen. Теперь я вполне могу обойтись одним терминалом.

Новое окно открывается комбинацией клавиш “Ctrl+a c”. После нажатия вы увидите новый терминал с вашим приглашением в том же окне. При этом предыдущие окна также продолжают работать. Давайте попробуем: запустите screen и в нем top

Mem: 506028K av, 500596K used, 5432K free,
0K shrd, 11752K buff
Swap: 1020116K av, 53320K used, 966796K free
393660K cached

PID USER PRI NI SIZE RSS SHARE STAT %CPU %ME
6538 root 25 0 1892 1892 596 R 49.1 0.3
6614 root 16 0 1544 1544 668 S 28.3 0.3
7198 admin 15 0 1108 1104 828 R 5.6 0.2

Теперь откройте новое окно, нажав “Ctrl+a c”

[boombick@server ] $

Вернитесь обратно, нажав Ctrl+a n

Mem: 506028K av, 500588K used, 5440K free,
0K shrd, 11960K buff
Swap: 1020116K av, 53320K used, 966796K free
392220K cached

PID USER PRI NI SIZE RSS SHARE STAT %CPU %ME
6538 root 25 0 1892 1892 596 R 48.3 0.3
6614 root 15 0 1544 1544 668 S 30.7 0.3

top остался в прежнем состоянии. Вы можете создать несколько окон и переключаться между ними используя Ctrl+a n для переключения на следующеее окно и Ctrl+a p для переключения на предыдущее. При этом каждый запущенный процесс останется в рабочем состоянии.

Отключаемся от screen
Есть два способа отключиться от screen: первый – это просто разлогиниться. Вы можете использовать клавиатурную комбинацию Ctrl+a K или просто набрать exit. Этот способ “убьет” текущее окно, если у вас их несколько или совсем остановит screen.
Второй способ заключается в отсоединении. Этот способ оставляет текущий процесс запущенным и просто отключает вас от терминала. Например, если вы через ssh-сессию запускаете какой-то очень длительный процесс, не требующий вашего внимания, то вы можете просто отключиться от screen при помощи Ctrl+a d. Это вернет вас обратно в исходную оболочку. Все процессы, запучшенные в screen, при этом остаются работающими и вы можете подключиться к ним позже.

Подключение к сессии
Вы компилируете большую программу на удаленном сервере, используя screen. И конечно же, по законам Мэрфи, соединение обрывается по независящим от вас причинам. Не стоит впадать в панику, screen все сохранил 🙂 Просто соединитесь с сервером еще раз и посмотрите запущеные под screen процессы при помощи

[root@server root]# screen -ls
There are screens on:
31619.ttyp2.server (Detached)
4731.ttyp2.server (Detached)
2 Sockets in /tmp/screens/S-root.

В этом примере запущено две screen-сессии. Для подключения к нужной из них используйте команду

[root@server root]#screen -r 31619.ttyp2.server

Просто используйте screen с флагом r и именем сессии для повторного подключения. Это очень удобно. Можно, например, запустить какой-то длительный процесс на работе и, вернувшись домой, продолжить контроль за его выполнением.

Логирование
Мне кажется очень важным порой сохранять полный лог своих действий. К счастью, screen легко с этим справляется. Просто активируйте логирование нажатием Ctrl+a H. Screen будет продолжать логирование на протяжении всего процесса работы. Бывает очень полезно вернуться назад и посмотреть порядок необходимых действий.

И еще немного…
Screen может вести мониторинг активности окна. Если вы качаете что-то большое, компилируете программу или просто выполняете длительный процесс, вы можете долгое время наблюдать пустой терминал без признаков активности. А процесс, тем временем, продолжает выполняться. Или, наоборот, смотреть на поток отладочной информации, ожидая окончания процесса. Для начала слежения перейдите в терминал, который вы хотите наблюдать и нажмите Ctrl+a M для слежения за активностью (сработает при появлении новой информации) или Ctrl+a _ для слежения за бездействием (сработает при прекращении поступления информации в терминал). Затем вы можете спокойно переключиться в другое окно или создать новое. При наступлении события, screen предупредит вас об этом сообщением с номером окна в заголовке терминала. Для быстрого переключения в это окно используйте Ctrl+a ” (это символ кавычки). Вы увидите список всех активных окон на данный момент. Для перехода в нужное можно использовать стрелки или просто набрать номер нужного окна. Для прекращения наблюдения перейдите в нужное окно и отмените мониторинг той же командой. Например, для прекращения наблюдения за активностью нажмите Ctrl+a M

Информация взята http://boombick.org/blog/posts/22

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

PHP, Оптимизация No Responses »

Гру 272011

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

Для того, чтобы прочитать в массив $x файл размером 1Мб (100 000 строк по 10 байт) можно воспользоваться двумя вариантами: чтение файла с помощью file(), либо традиционным методом fopen/fgets. Разумеется, для файлов разного объема и содержимого скорость может меняться. Но в данном примере статистика такова:file("1Mb_file.txt") работает на 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 Кб не представляется возможным, т.к. операцию чтения нельзя повторять в течении одного теста, операции чтения будут кешироваться…

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

PHP, Оптимизация No Responses »

Гру 272011

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

В начале программы создается массив $test из целых чисел (100 000 элементов). Потом один раз запускаются приведенные ниже примеры. Цикл проходит данный массив 3-мя способами (разными циклами) и выполняет кое-какие операции. Не выполнять в цикле ничего нельзя, ибо это будет уже совсем не реальный тест.

{$x=0; foreach($test as $n) { $x=sprintf("test%08i",$i); }}
{$x=0; for ($it=0; $it<100000; $it++) { $x=sprintf("test%08i",$i); }}
{$x=0; $it=0; while($it<100000) { $x=sprintf("test%08i",$i); $it++; }}
{$x=0; for ($it=0; $it<count($test); $it++) { $x=sprintf("test%08i",$i); }}
{$x=0; $it=0; while($it<count($test)) { $x=sprintf("test%08i",$i); $it++; }}
{$x=0; $co=count($test); for ($it=0; $it<$co; $it++) { $x=sprintf("test%08i",$i); }}
{$x=0; $co=count($test); $it=0; while($it<$co) { $x=sprintf("test%08i",$i); $it++; }}

счетчик	кол-во вызовов	общее вpемя	сpеднее вpемя	% от min	% от max
test N1	1	12.0313	12.0313	154.4%	100.0%
test N2	1	4.7290	4.7290	00.0%	39.3%
test N3	1	4.7712	4.7712	00.9%	39.7%
test N4	1	10.2847	10.2847	117.5%	85.5%
test N5	1	10.3466	10.3466	118.8%	86.0%
test N6	1	9.1271	9.1271	93.0%	75.9%
test N7	1	9.1409	9.1409	93.3%	76.0%

Почему 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 элементов:

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

счетчик	кол-во вызовов	общее вpемя	сpеднее вpемя	% от min	% от max
test N1	1	3.0087	3.0087	15.7%	100.0%
test N2	1	2.5998	2.5998	00.0%	86.4%

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

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

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

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

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

{$x=0; foreach($test as $k=>$v) { $x=sprintf("%s=>%s\n",$k,$v); }}
{$x=0; reset($test); while (list($k, $v) = each($test)) { $x=sprintf("%s=>%s\n",$k,$v); }}
{$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]]); }}
{$x=0; reset($test); while ($k=key($test)) { $x=sprintf("%s=>%s\n",$k,current($test)); next($test); }}

счетчик	кол-во вызовов	общее вpемя	сpеднее вpемя	% от min	% от max
test N1	1	8.1222	8.1222	00.0%	78.7%
test N2	1	10.3221	10.3221	27.1%	100.0%
test N3	1	9.7921	9.7921	20.6%	94.9%
test N4	1	8.9711	8.9711	10.5%	86.9%

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

счетчик	кол-во вызовов	общее вpемя	сpеднее вpемя	% от min	% от max
test N1	1	14.4473	14.4473	00.0%	67.2%
test N2	1	18.6801	18.6801	29.3%	86.9%
test N3	1	21.5056	21.5056	48.9%	100.0%
test N4	1	15.8514	15.8514	09.7%	73.7%

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

счетчик	кол-во вызовов	общее вpемя	сpеднее вpемя	% от min	% от max
test N1	1	3.5116	3.5116	00.0%	82.8%
test N2	1	3.9724	3.9724	13.1%	93.6%
test N3	1	4.2436	4.2436	20.8%	100.0%
test N4	1	4.0026	4.0026	14.0%	94.3%

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

Резюме:

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

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

PHP, Оптимизация No Responses »

Гру 272011

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

PHP поддерживает регулярные выражения стандарта POSIX/eger*/ и PERL/preg*/-ориентированные (об их различии тут – php.spb.ru/regular_expression.html). Кто из них работает быстрее?

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

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

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

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

счетчик	кол-во вызовов	общее вpемя	сpеднее вpемя	% от min	% от max
test N1	1	1.3339	1.3339	107.8%	100.0%
test N2	1	0.6417	0.6417	00.0%	48.1%

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

счетчик	кол-во вызовов	общее вpемя	сpеднее вpемя	% от min	% от max
test N1	1	0.4521	0.4521	76.9%	100.0%
test N2	1	0.2556	0.2556	00.0%	56.5%

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

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

счетчик	кол-во вызовов	общее вpемя	сpеднее вpемя	% от min	% от max
test N1	1	1.3430	1.3430	60.6%	100.0%
test N2	1	0.8365	0.8365	00.0%	62.3%

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

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

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

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

счетчик	кол-во вызовов	общее вpемя	сpеднее вpемя	% от min	% от max
test N1	1	11.6828	11.6828	680.3%	100.0%
test N2	1	1.4973	1.4973	00.0%	12.8%

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

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

{eregi("([a-z_-]+@([a-z][a-z-]*\.)+([a-z]{2}|com|mil|org|net|gov|edu|arpa|info|biz))",$text,$ok); echo $ok[1];}
{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];}

счетчик	кол-во вызовов	общее вpемя	сpеднее вpемя	% от min	% от max
test N1	1	0.5854	0.5854	00.0%	10.2%
test N2	1	5.7671	5.7671	885.2%	100.0%

Что мы видим?.. Ничто в этом мире не совершенно. Конечно, это очень не оптимизированное выражение для поиска email’ов, но всё же все те, кто кричал мне в форуме “ereg – отстой”, на этом и похожих примерах могут отдыхать. Бывает же, что в тексте нет ни одной собачки 🙂

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

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

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

счетчик	кол-во вызовов	общее вpемя	сpеднее вpемя	% от min	% от max
test N1	1	17.6384	17.6384	72381.4%	100.0%
test N2	1	0.0243	0.0243	00.0%	00.1%

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

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

PHP, Оптимизация No Responses »

Гру 272011

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

При использовании многомерных массивов в строках наблюдается заметное снижение скорости Из-за многомерности нужно заключать переменные в парные фигурные скобки.

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

счетчик	кол-во вызовов	общее вpемя	сpеднее вpемя	% от min	% от max
test N1	1	3.5369	3.5369	00.0%	69.9%
test N2	1	5.0605	5.0605	43.1%	100.0%
test N3	1	4.6017	4.6017	30.1%	90.9%

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

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

счетчик	кол-во вызовов	общее вpемя	сpеднее вpемя	% от min	% от max
test N1	1	3.3012	3.3012	00.0%	73.1%
test N2	1	4.1667	4.1667	26.2%	92.3%
test N3	1	4.5145	4.5145	36.8%	100.0%

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

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

счетчик	кол-во вызовов	общее вpемя	сpеднее вpемя	% от min	% от max
test N1	1	2.8495	2.8495	00.0%	80.9%
test N2	1	2.9519	2.9519	03.6%	83.9%
test N3	1	3.5202	3.5202	23.5%	100.0%

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

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

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

счетчик	кол-во вызовов	общее вpемя	сpеднее вpемя	% от min	% от max
test N1	1	6.5843	6.5843	00.0%	78.0%
test N2	1	6.7770	6.7770	02.9%	80.3%
test N3	1	8.4406	8.4406	28.2%	100.0%

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

Older Entries Newer Entries