Спонсорские ссылки
-
Статья
Версия для печати
Обсудить на форуме (3)
Сравнительный тест систем кэширования пользовательских данных для PHP.

Роман Чернышов (rxl@mail.ru)
15.08.2008

Содержание.


Введение.

Началось все с того, что захотелось уменьшить время отклика страниц. Не разбираясь особо, я поставил на наш клубный сервер eAccelerator. Он умеет кэшировать скомпилированные в байт-код php-файлы, имеет оптимизатор кода и позволяет кэшировать пользовательские данные и данные сессий. Время отклика снизилось на разных сайтах в 2-10 раз, в зависимости от внутренней логики движков: которые попроще - страницы просто вылетают, которые помудренее - немного быстрее стали работать.
Потом в голове возник вопрос: а правильный ли выбор я сделал. Стал искать сравнительные тесты в интернете и ничего стоящего не нашел. Даже странно стало: оптимизаторы php существуют не первый год, а сравнений никто не проводил. Даже если кто их и делал, то в поисковых системах они погребены под горами мусора.
Рассмотрев список бесплатно доступных систем, составил следующий список: eAccelerator, APC, XCache и Memcache.
Первые три умеют кэшировать скомпилированные php-файлы, eAccelerator и APC имеют оптимизаторы кода, Memcache же является отдельным кэширующим сервером и к php имеет отношение только тем, что для работы с ним существует php-модуль.

Краткий обзор.

eAccelerator

http://bart.eaccelerator.net/doc/phpdoc/
По API больше понравился eAccelerator. API простое - только самое нужное, но есть и такие возможности, которых нет у других - функции блокировки ключа. Документация неудобная, но информация понятна и есть толковые примеры. Он также лучше и удобнее в настройках. Позволяет отдельно управлять хранением ключей, сессий и данных (скомпилированного кода и пользовательских данных). Методы хранения: только в разделяемой памяти, в памяти и на диске одновременно, в памяти с вытеснением на диск и только на диске. Легко и прозрачно можно отделить ключи каждого виртуального сервера в системе, чтобы не было лишних дырок в безопасности и пересечения ключей, установкой уникального значения параметра eaccelerator.name_space для каждого виртуального сервера. Переписал код club.shelek.ru на работу с кэшем: среднее время генерации страницы всего 4-5 мс против 90-120 без кэша. Против ожидания, что нагрузка на процессор и память возрастет, наблюдаю, наоборот, снижение за счет меньшей нагрузки на базу данных. Посмотрим, как он покажет себя при длительной эксплуатации.

APC

http://www.php.net/apc
APC очень обилен в настройках. Пока я предпочел не крутить настройки, а пользоваться значениями по умолчанию. API очень маленькое. Интересная функция - сохранение массива и восстановление его как набора констант. Редкая по нужности функция.

XCache

http://xcache.lighttpd.net/wiki/XcacheApi
После eAccelrator и APC XCache ничем хорошим не удивил. Отвратительная документация по API без единого комментария (я назвал ее "черный квадрат"), хотя для базовых функций даны примеры, и то хорошо. API простое. Из особенностей: возможность выполнять инкремент и декремент числового значения в кэше и функция проверки наличия ключа в кэше без пересылки самого значения. Настроек довольно мало. Удивило то, что кэширование по умолчанию разрешено, но размер используемой памяти и максимальные размеры пользовательских объектов равны нулю, что по документации означает "запрещено".

Memcache

http://www.php.net/memcache
Memcache минималистичен в настройках, так как настройки управления кэшированием находятся на стороне сервера memcached. API у него посложнее, чем у первых трех систем, и поддерживает работу в процедурном и ООП способах. Из особенностей: помимо функции установки значения по ключу есть возможность добавить ключ, только если его еще нет, и перезаписать, только если он уже есть. Может иметь несколько кэширующих серверов: как на том же хосте, так и на других. Как я понял, суть Memcache - в использовании ресурсов других хостов. По моему мнению, это несколько устарело: если ресурсов одного хоста не хватает, то лучше найти другой способ распределить нагрузку, чем коммуникация по TCP с кэширующими серверами на других хостах, что вносит существенную задержку. Тем не менее, Memcache в сети упоминается часто, из чего делаю вывод о его популярности и включаю в список тестируемых систем.

Подготовка к тестам.

Тестировать все это на живом сервере я не рискнул и использовал виртуальную машину. Все программы, которые могли вызвать неожиданную нагрузку на систему и повлиять на результаты замеров, были остановлены.
Условия тестов:

  • Хост система: одноядерный P4 2800 ГГц, 1.5 ГБ памяти DDR-400, Windows XP Professional SP2, VMware Workstation 5.5.1.
  • Виртуальная система: 512 МБ, Linux CentOS 5.1, Apache 2.2.3, PHP 5.1.6, gcc 4.1.2.

Тестируемые программы были собраны на этом виртуальном хосте с дополнительным ключом компиляции -O3. Для компиляции потребовалось скомпилировать и установить программу re2c версии 0.13.5.
Версии программ:

  • eAccelerator - 0.9.5.3
  • APC - 3.0.19
  • XCache - 1.2.2
  • Memcache - 3.0.1
  • Memcached - 1.2.6

Всем кэш-системам было выделено по 64 МБ разделяемой памяти. Оптимизация кода была включена. Перед каждым тестом каждой системы исправлялся конфиг php.ini, чтобы загружалась только тестируемая система, и выполнялся рестарт демона httpd.
Лимит времени работы скрипта был убран, память, выделяемая процессу, - 200МБ (сначала было 16, но об этом чуть позже). Время измерялось php-функцией microtime(true) с точностью до микросекунд.
Работу с кэш-системами обеспечивал класс, написанный несколькими днями ранее.

Код: (PHP)
<?php

// (c) 2008 Veselchak U

class Cache
{
    var $_cache_type = 'auto'; // дефолтное значение
    var $_memcache = null;

    function __constructor($options = null)
    {
        $this->Cache($options);
    }

    function Cache($options = null)
    {
        // Проверка поддержки кеш-систем
        $cache_systems = array();

        if (function_exists('eaccelerator_get'))
            $cache_systems[] = 'eaccelerator';

        if (function_exists('apc_fetch'))
            $cache_systems[] = 'apc';

        if (function_exists('xcache_get'))
            $cache_systems[] = 'xcache';

        if (class_exists('Memcache'))
            $cache_systems[] = 'memcache';

        $required_cache = isset($options['cache']) ? $options['cache'] : $this->_cache_type;

        if (count($cache_systems) && $required_cache != 'none')
        {
            if ($required_cache == 'auto')
                $this->_cache_type = array_shift($cache_systems); // первое значение в списке
            else if (in_array($required_cache, $cache_systems))
                $this->_cache_type = $required_cache;
            else
                $this->_cache_type = 'none';
        }
        else
            $this->_cache_type = 'none';

        if ($this->_cache_type == 'memcache')
        {
            $failed = true;

            if (isset($options['memcache']) && is_array($options['memcache']))
            {
                $this->_memcache = new Memcache;

                foreach ($options['memcache'] as $server)
                {
                    if (!is_array($server) || !isset($server['host'])) // host должен быть указан
                        continue;

                    $server['port'] = isset($server['port']) ? (int) $server['port'] : ini_get('memcache.default_port');
                    $server['persistent'] = isset($server['persistent']) ? (bool) $server['persistent'] : true;

                    if ($this->_memcache->addServer($server['host'], $server['port'], $server['persistent']))
                        $failed = false;
                }

                if ($failed)
                    $this->_memcache = null;
            }

            if ($failed)
                $this->_cache_type = 'none';
        }
    }

    function get($key)
    {
        $data = null;

        switch ($this->_cache_type)
        {
            case 'none':
                break;
            case 'eaccelerator':
                $data = eaccelerator_get($key);
                break;
            case 'apc':
                $data = apc_fetch($key);
                break;
            case 'xcache':
                $data = xcache_get($key);
                break;
            case 'memcache':
                $data = $this->_memcache->get($key);
                break;
        }

        return $data;
    }

    function put($key, &$data, $ttl)
    {
        switch ($this->_cache_type)
        {
            case 'none':
                break;
            case 'eaccelerator':
                eaccelerator_put($key, $data, $ttl);
                break;
            case 'apc':
                apc_store($key, $data, $ttl);
                break;
            case 'xcache':
                xcache_set($key, $data, $ttl);
                break;
            case 'memcache':
                // Решение set() проблемы с несколькими серверами.
                // http://www.php.net/manual/ru/function.memcache-set.php#84032
                if (!$this->_memcache->replace($key, $data, MEMCACHE_COMPRESSED, $ttl))
                    $this->_memcache->set($key, $data, MEMCACHE_COMPRESSED, $ttl);

                break;
        }
    }
}

?>

Для тестов были созданы 4 файла:

Название Размер
Тест 1
1028299
Тест 2
101600
Тест 3
10081
Тест 4
1010

Содержимое каждого файла представляет собой сериализованный массив, заполненный случайными значениями. Размеры их, как видите, приблизительно равны 1МБ, 100кБ, 10кБ и 1кБ. В каждом тесте каждая система тестировалась с каждым из этих файлов.

Тесты.

Заранее говорю, что тесты искусственные. К реальности приближен только третий тест, но и у него временами были трудности с точностью измерения очень малых промежутков времени. Главное здесь - в сравнении работы четырех подопытных кэш-систем в одинаковых условиях.
Для большей наглядности я добавил к тестируемым кэш-системам еще и простое чтение файла. В первом тесте их было два:
  • Открытие файла, запись, перемещение позиции на начало, чтение, закрытие.
  • Открытие файла, запись, закрытие и последующее чтение функцией file_get_contents().
Для остальных тестов использовалось только чтение файла функцией file_get_contents().

Тест первый. Зверский.

Алгоритм теста такой: в кэш загружается пара ключ-значений и тут же считывается. Операция многократно повторяется. Контрольное время замеряется до и после цикла. Тест повторяется пять раз в течение одного запуска тестового скрипта. Результатом будет среднее значение этих пяти замеров.
Я подумал, что если размеры тестовых данных уменьшаются в десять раз от файла к файлу, то и число повторов тестовой операции стоит повышать в десять раз при переходе к следующему файлу. Для файла "Тест 1" было выполнено 10 повторов. Соответственно, для файла "Тест 4" - 10000.
Результаты тестирования представлены в таблице. Время - в секундах.

СистемаТест 1Тест 2Тест 3Тест 4
Файл 1
2.336
2.561
2.191
5.407
Файл 2
2.571
2.128
3.088
8.406
eAccelerator
0.432
0.402
0.338
0.475
APC
9.699
10.036
10.264
13.970
XCache
0.482
0.946
0.928
1.521
Memcache
3.918
3.508
3.650
4.804

В графическом виде это выглядит так:


Сначала протестировал работу с файлами, eAccelerator, APC и Memcache, а когда перешел к XCache, то скрипт стал аварийно завершаться. В логах Апача было сообщение о нехватке памяти. Увеличил размер с 16 до 32 МБ и повторил эксперимент: опять падение. 128 МБ - тоже. 192 - опять. На 200 МБ скрипт отработал до конца без ошибок. Вот такой вот он - XCache. Пришлось проводить тест для всех систем заново, с едиными условиями. При этом время работы всех систем, кроме Memcache, серьезно сократилось: в 1.5-2 раза. Видимо, за счет уменьшения работ по сборке мусора.
Поразила скорость APC: в 2-4 раза медленнее, чем работа с файлами. Memcache тоже оказался не на высоте. eAccelerator, похоже, даже не заметил разницу: что 1 МБ, что 1 кБ, что 10 циклов, что 10000.

Тест второй. Многократное чтение.

На следующий день я поискал в интернете впечатления других людей об APC - аутсайдере моего теста и, что интересно, ничего плохого не нашел. Поэтому я решил провести еще один тест, более приближенный к реальности. За основу взял первый тест и изменил алгоритм: считывается тестовый файл, помещается в кэш и в цикле считывается. Время измерялось до функции чтения и после, помещалось в массив, а после цикла производилось усреднение результата. Количество циклов было аналогично первому тесту: от 10 до 10000.
Результаты представлены в таблице. Время - в секундах.

СистемаТест 1Тест 2Тест 3Тест 4
Файл
0.121911
0.008692
0.001274
0.000242
eAccelerator
0.025335
0.002391
0.000201
0.000025
APC
0.099481
0.008770
0.001281
0.000173
XCache
0.064841
0.006181
0.000710
0.000092
Memcache
0.109873
0.010685
0.002072
0.001027

Графическое представление, к сожалению, менее наглядно - цирфы говорят здесь лучше.


На больших объемах хорошо видно, кто первый, а кто отстающий. На малых размерах разница не столь велика. Лидеры, по-прежнему, eAccelerator и XCache, APC и Memcache работают чуть быстрее, чем работа с файлом (надо понимать, что файл считывался не с диска, т.к. Linux кэширует файловые операции).
Что интересно, здесь у XCache тоже были проблемы с нехваткой памяти, поэтому опять было выделено 200 МБ на процесс.

Тест третий. В погоне за реальностью.

Второй тест меня тоже не убедил, и я решил сделать замеры одиночных запросов в кэш (как в реальной работе сайта): всего четыре запроса на один запуск скрипта. Это чтобы ликвидировать возможное кэширование в php или какие-то подобные процессы.
Для этого сначала запускался скрипт, который считывал все четыре файла и помещал их в кэш с разными ключами. Потом многократно запускался скрипт, который производил считывание из кэша всех четырех блоков данных и замер времени на каждое чтение.
Точность замеров очень плохая. Порой результат был - ноль. Еще я подметил, что после рестарта Апача первые 5-7 замеров для всех систем были большими, а потом сокращались в 2-3 раза. Чтобы компенсировать этот эффект, результаты первых 10 запусков я отбрасывал, а следующих 10 - записывал и потом усреднял. Все равно результаты приблизительные. Я оцениваю их точность - плюс-минус 10%.
Результат показан в таблице. Время - в микросекундах.

СистемаТест 1Тест 2Тест 3Тест 4
Файл
76934
26083
2807
721
eAccelerator
90
7
6
6
APC
181
64
57
60
XCache
251
15
14
12
Memcache
167515
27784
3164
1264

Чтобы графическое представление не было таким же неинтересным, как и во втором тесте, убрал полных аутсайдеров: работу с файлами и Memcache.


В лидерах, по-прежнему, eAccelerator и XCache. Даже помня о точности замеров, не приходится сомневаться, что APC работает в несколько раз медленнее, чем eAccelerator, а XCache плохо переваривает большие объемы данных.

Заключение.

Как поведут себя эти кэш-системы в реальных условиях, предсказать трудно - ведь эти условия могут быть очень разными и не иметь ничего общего с моими тестами. По крайней мере, тесты подняли на поверхность некоторые недостатки, о которых полезно будет знать.
Мне хотелось бы провести более реальные тесты. Если вы поможете составить алгоритм, то я попробую провести их и результаты опубликую на сайте нашего клуба. Пишите предложения на наш форум в раздел web-программирования.
Версия для печати
Обсудить на форуме (3)