Memcached сколько выделить памяти
See the doc/protocol.txt file within the tarball or on github for detailed information.
It's important that you look at the protocol.txt file from the version of memcached you run, as stats counters and commands are routinely updated.
Memcached comes equipped with basic documentation about its commandline arguments. View memcached -h or man memcached for up to date documentation. The service strives to have mostly sensible defaults.
When setting up memcached for the first time, you should pay attention to -m , -d , and -v .
-m tells memcached how much RAM to use for item storage (in megabytes). Note carefully that this isn't a global memory limit, so memcached will use a little more memory than you tell it to. Set this to safe values. Setting it to less than 64 megabytes may still use up to 64 megabytes as a minimum.
-d tells memcached to daemonize. If you're running from an init script you may not be setting this. If you're using memcached for the first time, it might be educational to start the service without -d and watching it.
-v controls verbosity to STDOUT/STDERR. Multiple -v 's increase verbosity. A single one prints extra startup information, and multiple will print increasingly verbose information about requests hitting memcached. If you're curious to see if a test script is doing what you expect it to, running memcached in the foreground with a few verbose switches is a good idea.
Most of the defaults are sensible. New features are often released as non-default options. Keep an eye on the ReleaseNotes for new options to try.
If you have installed memcached from your OS's package management system, odds are it already comes with an init script. They come with alternative methods to configure what startup options memcached receives. Such as via a /etc/sysconfig/memcached file. Make sure you check these before you run off editing init scripts or writing your own.
If you're building memcached yourself, the 'scripts/' directory in the source tarball contains several examples of init scripts.
Running multiple local instances of memcached is trivial. If you're maintaining a developer environment or a localhost test cluster, simply change the port it listens on, ie: memcached -p 11212 .
Since 1.5.6 memcached defaults to listening only on TCP. -l allows you to bind to specific interfaces or IP addresses. Memcached does not spend much, if any, effort in ensuring its defensibility from random internet connections. So you must not expose memcached directly to the internet, or otherwise any untrusted users. Using SASL authentication here helps, but should not be totally trusted.
-p changes where it will listen for TCP connections. When changing the port via -p , the port for UDP will follow suit.
-U modifies the UDP port, defaulting to off since 1.5.6. UDP is useful for fetching or setting small items, not as useful for manipulating large items. Setting this to 0 will disable it, if you're worried.
If you wish to restrict a daemon to be accessable by a single local user, or just don't wish to expose it via networking, a unix domain socket may be used. -s is the parameter you're after. If enabling this, TCP/UDP will be disabled.
By default the max number of concurrent connections is set to 1024. Configuring this correctly is important. Extra connections to memcached may hang while waiting for slots to free up. You may detect if your instance has been running out of connections by issuing a stats command and looking at "listen_disabled_num". That value should be zero or close to zero.
Memcached can scale with a large number of connections very simply. The amount of memory overhead per connection is low (even lower if the connection is idle), so don't sweat setting it very high.
Lets say you have 5 webservers, each running apache. Each apache process has a MaxClients setting of 12. This means that the maximum number of concurrent connections you may receive is 5 x 12 (60). Always leave a few extra slots open if you can, for administrative tasks, adding more webservers, crons/scripts/etc.
Threading is used to scale memcached across CPU's. The model is by "worker threads", meaning that each thread handles concurrent connections. Since using libevent allows good scalability with concurrent connections, each thread is able to handle many clients.
This is different from some webservers, such as apache, which use one process or one thread per active client connection. Since memcached is highly efficient, low numbers of threads are fine. In webserver land, it means it's more like nginx than apache.
By default 4 threads are allocated. Unless you are running memcached extremely hard, you should not set this number to be any higher. Setting it to very large values (80+) will make it run considerably slower.
Inspecting Running Configuration
cool huh? Between 'stats' and 'stats settings', you can double check that what you're telling memcached to do is what it's actually trying to do.
Memcache разработан для кэширования данных, генерация которых требует большого количества ресурсов. Такого рода данные могут содержать что угодно, начиная с результатов запроса к базе данных и заканчивая тяжеловесным куском шаблона. Memcached не входит в базовый набор модулей, поставляемых с PHP, однако он доступен в репозитории pecl.
Практика
На практике чистый Memcached никто не использует. Обычно используют какой-то класс-обертку, который поддерживает тегирование. Самым распространенным является решение ZendCache
Структура должна быть такой, если смотреть от корня
/lib/DklabCache/.
/class/Cache.class.php
/stat.php
/get_post.php
/update_post.php
Класс-обертка (или как еще называют — врапер (wrapper)) с использованием ZendCache
Это у нас класс-синглтон, говоря простыми словами, при первом вызове создается экземпляр класса (читай, подключение к Memcached) и используется при следующем вызове. Таким образом, в пределах одного скрипта мы не плодим лишние подключения и экономим ресурсы.
Константа CACHE_USE прописывается отдельно в конфиге. С помощью нее можно включать/выключать кэширование.
Параметр 'compression' => false означает, что мы не сжимаем данные в кэше. Сжатие нужно для экономии места в памяти, но сжатие требует некоторого времени. Поэтому, если для вас не критичен объем памяти, то сжатее отключаем.
Параметр 'persistent' => false означает выключение постоянного соединения (по аналогии с mysql_pconnect())
Кстати говоря, тут видно как использовать несколько серверов. Если у нас 1 сервер
Например у нас 3 сервера Memcached
По-хорошему, подобные вещи нужно вынести из класса в конфиг.
Теперь подключаем этот класс в скрипт, в котором мы хотим что-то кэшировать
Допустим скрипт вывода поста (в архиве это get_post.php)
Примеры конечно не самые лучшие, но лучше так, чем совсем ничего.
Работу с базой я специально отключил, что бы у вас было меньше проблем.
После чего запускаем скрипт get_post.php и видим, что данных в кэше не было и мы снова сохранили их туда: 'сохранили данные в кэш'.
На самом деле самое сложное в кэшировании, это простановка правильных тегов. Чтобы при обновлении поста обновилась данные, в которых лежит этот пост.
На примере выше это были теги
- 'post_update_'.$postID — сам пост (обычно страница вывода поста)
- 'post_blog_'.$blogID — страница блога, где выводится список постов этого блога
- 'post_update' — тег связанный с главной страницей или списком самых лучших постов
Дополнительная оптимизация памяти
Опция “-L” заставляет Memcache во время старта подготовить всю выделяемую ему память для использования. Это значит, что во время старта Memcache сделает инициализацию слабов и чанков. И не будет этого делать в процессе работы. Это разгрузит сервер во время работы:
Dog-pile эффект
Переводится как «стая собак». Допустим, у вас есть какая-то сложная выборка из базы на 2 секунды. В кэше ее еще нет (или мы сбросили кэш). Приходит первый пользователь, идет запрос в базу, и только спустя 2 секунды эти данные появятся в кэше. Так вот, за эти 2 секунды на сайт могут зайти еще 10 человек, которые инициируют еще 10 таких же сложных запросов в базу (так как данных в кэше еще нет, а первый запрос всё еще выполняется). Отсюда и получается стая собак, которые нагружают сервак.
выглядит это примерно как-то так:)
Решение проблемы описано здесь.
Код выше не предусматривает защиты от dog-pile эффекта. В моем случае нет такой высокой посещаемости и долгих запросов.
Memcache работает очень быстро, но эффективность расходования памяти в нем можно повысить. Для того, чтобы это сделать, необходимо разобраться в его структуре хранения данных.
Обращение от редакции: Нашим защитникам из 3-го отдельного батальона УДА, которые находятся в Запорожской области, нужны вещи, чтобы противостоять врагу: квадрокоптеры и смартфоны для управления ими, прицелы ночного видения. Реквизиты для перевода средств на карту monobank – Колонович Катерина, номер карты 5375411505235312. Просим приобщиться к сбору средств. Слава Украине!
SLAB – это алгоритм выделения памяти. Он был создан для ее эффективного использования. Вся память делится на отдельные куски – слабы (slab). Каждый слаб содержит более мелкие куски – чанки (chunk). Когда в память нужно что-то сохранить, мы находим пустой слаб, в нем пустой чанк и записываем туда данные. Когда нужно будет сохранить что-то еще, мы переходим к следующему чанку и сохраняем данные в него.
Представьте, что вся память – это дом. Слабы – это квартиры, а чанки – это комнаты. Это эффективно, т.к. нам не нужно постоянно искать по всей памяти какое-то свободное место. Мы просто заполняем комнату, потом переходим к следующей комнате и т.п. И так пока вся память не будет заполнена.
Размеры чанков
Для того, чтобы работать с объектами разных размеров Memcache создает несколько разных слабов (квартир в доме), в которых находятся чанки разных размеров (в некоторых побольше, а в некоторых поменьше):
Когда приходит объект покрупнее, Memcache использует чанки из того слаба, в котором они большие. Главное, чтобы размер объекта был меньше, чем размер чанка. Слабы, в которых находятся чанки одинакового размера объединяются в классы (slabclass). Таким образом:
- Slabclass определяет группу слабов с одинаковым размером чанков.
- Slab содержит группу чанков.
- Чанк – это кусочек памяти, в который сохраняются данные.
Если у нас большие чанки и много мелких объектов, мы рискуем использовать память очень неэффективно. Если объекты большие и много мелких чанков, то эти чанки не будут использованы. В обоих случаях мы не используем все место, которое можем.
Параметры Memcache
Для настройки используется два параметра во время запуска сервера Memcached:
- Фактор роста
- Минимальный размер чанка (с которого начинается прирост)
Для установки размера минимального чанка используется параметр “-n”:
Этот параметр следует уменьшить до 16, если у Вас в кэше есть мелкие объекты, например:
- счетчики
- флаги
- короткие строчные значения (имейлы, пароли, хеши и т.п.)
Второй параметр – это фактор роста. Он задается опцией “-f”. Уменьшение этой опции до 1.05 позволит создать больше слабклассов, а следовательно более эффективно выделять память под объекты различного размера. Чем больше классов, тем больше выбор из чанков, а значит больше вероятности подобрать чанк нужного размера:
Установка и настройка
В качестве рассматриваемого дистрибутива я решил использовать Debian, потому как он наиболее часто используется при создании web-серверов. Модуль Memcached для PHP доступен в репозитории уже скомпилированным (php5-memcached), но я опишу процесс установки из исходного кода, так как не все репозитории настолько богаты, как дебиановский.
Устанавливаем сервер Memcached
Проверяем
Компилируем и устанавливаем модуль для PHP
apt-get install php5-dev libmemcache-dev
pecl download memcache
tar xzvf memcache-2.2.6.tgz
cd memcache-2.2.6 /
phpize && . / configure --enable-memcache && make
cp modules / memcache.so / usr / lib / php5 / 20060613 /
echo 'extension=memcache.so' >> / etc / php5 / apache2 / php.ini
/ etc / init.d / apache2 restart
Настройка размеров чанка
В Memcache настройка размеров чанков и их количества производится с помощью фактора роста. Это соотношение размера большего чанка к меньшему:
Так при факторе роста в 1.25 будет такое распределение классов:
Тегирование
Так как Memcached чрезвычайно прост (данные никак не связаны между собой — есть только связь ключ-значение), то возникают некоторые трудности на практике. Допустим, у нас есть блоги как на Хабре. Мы написали пост, сохранили его в кэш. Создали несколько пар ключ-значение: кэш под сам пост, кэш для блога, в котором отображается этот пост, кэш для прямого эфира, кэш для вывода постов пользователя в профиле этого пользователя и т.д.
$memcache->set('post_id_2211', 'данные');
$memcache->set('post_blog_id_11', 'данные');
$memcache->set('live_posts', 'данные');
$memcache->set('post_user_id_331', 'данные');
Но вдруг модератор удалил пост. Нам нужно очистить все кэши, которые связаны с этим постом.
$memcache->delete('post_id_2211');
$memcache->delete('post_blog_id_11');
$memcache->delete('live_posts');
$memcache->delete('post_user_id_331');
…
Короче, из-за простоты Memcached нам приходится ручками плодить лишний код. Более того, мы должны постоянно помнить какие кэши связаны с другим кэшем. Решение проблемы очень простое. Мы к каждому элементу кэша прикрепляем тег или несколько тегов.
Подробнее можно почитать здесь.
Проверка
Обычно Memcached стоит на localhost и доступен через порт 11211
Смотрим статистику
Результат:
Array
(
[pid] => 5915
[uptime] => 583
[time] => 1309538445
[version] => 1.2.2
[pointer_size] => 64
[rusage_user] => 0.000000
[rusage_system] => 0.004000
[curr_items] => 0
[total_items] => 0
[bytes] => 0
[curr_connections] => 1
[total_connections] => 2
[connection_structures] => 2
[cmd_get] => 0
[cmd_set] => 0
[get_hits] => 0
[get_misses] => 0
[evictions] => 0
[bytes_read] => 7
[bytes_written] => 0
[limit_maxbytes] => 1073741824
[threads] => 1
)
Через какое-то время статистика будет выглядеть примерно так
Array
(
[pid] => 5915
[uptime] => 6202245
[time] => 1315740107
[version] => 1.2.2
[pointer_size] => 64
[rusage_user] => 3.464216
[rusage_system] => 10.868679
[curr_items] => 298
[total_items] => 17728
[bytes] => 120366
[curr_connections] => 1
[total_connections] => 28654
[connection_structures] => 4
[cmd_get] => 133296
[cmd_set] => 17728
[get_hits] => 124758
[get_misses] => 8538
[evictions] => 0
[bytes_read] => 11125692
[bytes_written] => 103815319
[limit_maxbytes] => 1073741824
[threads] => 1
)
Оновные параметры:
[curr_items] => 298 — сколько текущих элементов в кэше.
[total_items] => 17728 — сколько всего было элементов в кэше (в том числе и удаленных)
[bytes] => 120366 — сколько байт сейчас лежит в кэше
[limit_maxbytes] =>1073741824 — сколько байт вообще доступно под кэш (тут 1 Gb)
[get_hits] => 124758 — сколько раз мы взяли данные из кэша
[get_misses] => 8538 — сколько раз мы пытались взять данные из кэша, но его там не было или время жизни кэша истекло.
Отношение get_misses/get_hits показывает эффективность использования кэша. Чем оно меньше, тем эффективней используется кэш. В данном случае у нас получается, что 93% данных берется из кэша. Если у вас get_misses/get_hits=1, то значит вы делаете что-то не так (скорее всего ставите слишком малое время жизни кэша).
визуальная статистика
Код выше выводит статистику в сухом виде типа print_r()
Есть красивый вывод статистики — phpMemcachedAdmin
Самое важное
Настройка Memcache может повысить эффективность использования памяти. В некоторых случаях – в несколько раз. Не торопитесь покупать новые сервера. Убедитесь, что текущее железо используется эффективно. Не забывайте проверять вытеснения ключей – это первый показатель нехватки памяти.
Примеры использования Memcache
Допустим, у нас есть строка 'test111', мы хотим ее закэшировать на 1 день. Придумаем ей какой-нибудь ключ 'key1'.
Только со второго запуска этого скрипта мы увидим наши данные.
Еще забыл добавить про время жизни кэша. Memcached имеет ограничение на время жизни — 1 месяц. Так вот, если вы поставите 365 дней, то Memcached просто не сохранит их, при этом не выдаст ни какой ошибки. Поэтому, если ваши данные долго не меняются и вы хотите поставить максимальный срок жизни, то указывайте false
$memcache->set($key, $result, false, false);
Особенность именования ключей. Лучше в качестве ключа брать md5(ключ), потому что максимальная длина ключа 250 символов и нельзя использовать пробелы. А когда вы будет кэшировать SQL-запросы с условием, то ключ будет типа $key = 'blog_id_1 WHERE activity=1 AND … AND … LIMIT 10'
Если этого не сделать, то второй сайт на том же сервере может перезаписать данные первого сайта с тем же ключом. Дело в том, что Memcached не имеет авторизации, как например база данных, поэтому приходится вот таким способом ограничивать доступ. Короче говоря, Memcached — это такая большая свалка пар ключ-значение. Поэтому все сайты хранят кэш в одном Memcached. При этом мы не можем, например, взять 10 последних записанных элементов (типа как в базе LIMIT 10). Структура Memcached необычайна проста, но за счет этого мы получаем высокую производительность.
Установка и настройка
В качестве рассматриваемого дистрибутива я решил использовать Debian, потому как он наиболее часто используется при создании web-серверов. Модуль Memcached для PHP доступен в репозитории уже скомпилированным (php5-memcached), но я опишу процесс установки из исходного кода, так как не все репозитории настолько богаты, как дебиановский.
Устанавливаем сервер Memcached
Проверяем
Компилируем и устанавливаем модуль для PHP
apt-get install php5-dev libmemcache-dev
pecl download memcache
tar xzvf memcache-2.2.6.tgz
cd memcache-2.2.6 /
phpize && . / configure --enable-memcache && make
cp modules / memcache.so / usr / lib / php5 / 20060613 /
echo 'extension=memcache.so' >> / etc / php5 / apache2 / php.ini
/ etc / init.d / apache2 restart
Особенности Memcached
- Простая структура хранения данных (ключ-значение).
- Максимальное время жизни кэша — 30 дней.
- Максимальный объем одного элемента — 1 Mb
- Можно хранить объекты, массивы как есть. При кэшировании в файлах или в базе подобные вещи нужно загонять в строку при помощи сериализации перед сохранением.
- Нет авторизации (пароль-логин). Т.е. если на сервере стоит Memcached, то любой пользователь на этом же сервере может получить к нему доступ.
- Скорость доступа к данным не зависит от кол-ва элементов в кэше. Да-да, именно так.
Использование памяти в чанках
Для скорости работы, Memcache выделяет чанки одинакового размера. Если значение сохраняемого объекта меньше, чем размер чанка, в памяти остается “свободное место”:
Это свободное пространство и определяет возможность оптимизации Memcache, т.к. размер чанков можно настроить.
Установка
В сети есть куча инструкций по установке, хоть на Unix, хоть на Windows. Кроме самого Memcached нужно еще поставить либу для обращения к Memcached через PHP (по аналогии с базой MySQL — кроме самой базы нужно еще поставить расширение mysql или mysqli).
Но проще всего написать хостеру. На fastvps при заказе сервера Memcached ставят по умолчанию. Главное, указать сколько памяти нужно выделить под кэш. По умолчанию это 67 Mb. У меня 4 Gb оперативы, то можно смело выделить 1 Gb. Вообще, самый простой способ оценить сколько нужно памяти под кэш, это умножить объем базы на 2. Например, базы на всех наших сайтах весят 300 Мб, то под кэш выделяем 600 Мб, а лучше брать 1 Гб, с запасом.
Memcached можно увидеть в phpinfo
Примеры использования
1. Базовые операции
- //Создаём новый объект. Также можно писать и в процедурном стиле
- $memcache_obj = new Memcache ;
- //Соединяемся с нашим сервером
- $memcache_obj -> connect ( '127.0.0.1' , 11211 ) or die ( «Could not connect» ) ;
- //Попытаемся получить объект с ключом our_var
- $var_key = @ $memcache_obj -> get ( 'our_var' ) ;
- if ( ! empty ( $var_key ) )
- //Если объект закэширован, выводим его значение
- echo $var_key ;
- >
- else
- //Если в кэше нет объекта с ключом our_var, создадим его
- //Объект our_var будет храниться 5 секунд и не будет сжат
- $memcache_obj -> set ( 'our_var' , date ( 'G:i:s' ) , false , 5 ) ;
- //Выведем закэшированные данные
- echo $memcache_obj -> get ( 'our_var' ) ;
- >
- //Закрываем соединение с сервером Memcached
- $memcache_obj -> close ( ) ;
- ?>
В результате выполнения этого кода каждый раз будет выводиться время с точностью до секунд. Однако обновляться оно будет раз в 5 секунд, пока не очистится кэш. В данном примере проиллюстрированы самые простые операции, но в производительности мы скорее потеряем, чем выиграем. Ведь нам каждый раз придётся подключаться к серверу…
2. Повышаем производительность
2.1 С кэшированием
- < ? php
- function LoadCPU ( )
- //Функция, которая должна зугрузить процессор
- //Создадим изображение 800x600
- $image = imagecreate ( 800 , 600 ) ;
- //Белый фоновый цвет
- $color = imagecolorallocate ( $image, 255 , 255 , 255 ) ;
- //Чёрный
- $color2 = imagecolorallocate ( $image, 0 , 0 , 0 ) ;
- for ( $i = 0 ; $i < 10000 ; $i ++ )
- //Расставим 10 000 точек в случайном порядке
- imagesetpixel ( $image, rand ( 0 , 800 ) , rand ( 0 , 600 ) , $color2 ) ;
- >
- //Выбрасываем указатель
- return $image ;
- >
- //Создаём новый объект Memcache
- $memcache_obj = new Memcache ;
- //Соединяемся с нашим сервером
- $memcache_obj - > connect ( '127.0.0.1' , 11211 ) or die ( "Could not connect" ) ;
- //Попытаемся получить объект с ключом image
- $image_bin = @$memcache_obj - > get ( 'image' ) ;
- if ( empty ( $image_bin ) )
- //Если в кэше нет картинки, сгенерируем её и закэшируем
- imagepng ( LoadCPU ( ) ,getcwd ( ) . '/tmp.jpg' , 9 ) ;
- $image_bin = file_get_contents ( getcwd ( ) . '/tmp.jpg' ) ;
- unlink ( getcwd ( ) . '/tmp.jpg' ) ;
- $memcache_obj - > set ( 'image' , $image_bin, false , 30 ) ;
- >
- //Выведем картинку из кэша
- header ( 'Content-type: image/png' ) ;
- echo $image_bin ;
- //Закрываем соединение с сервером Memcached
- $memcache_obj - > close ( ) ;
- ? >
В данном примере приведена функция, которая создаёт изображение размером 800x600 и расставляет на нём 10 000 точек. Один раз, сгенерировав такое изображение, в дальнейшем мы лишь выводим его на экран, не генерируя заново.
2.2 Без кэширования
- function LoadCPU ( )
- //Функция, которая должна загрузить процессор
- //Создадим изображение 800x600
- $image = imagecreate ( 800 , 600 ) ;
- //Белый фоновый цвет
- $color = imagecolorallocate ( $image , 255 , 255 , 255 ) ;
- //Чёрный
- $color2 = imagecolorallocate ( $image , 0 , 0 , 0 ) ;
- for ( $i = 0 ; $i < 10000 ; $i ++ )
- //Расставим 10 000 точек в случайном порядке
- imagesetpixel ( $image , rand ( 0 , 800 ) , rand ( 0 , 600 ) , $color2 ) ;
- >
- //Выбрасываем указатель
- return $image ;
- >
- //Выводим изображение, не кэшируя
- header ( 'Content-type: image/png' ) ;
- imagepng ( LoadCPU ( ) , '' , 9 ) ;
- ?>
Тут всё гораздо проще и привычней: генерируем изображение каждый раз заново.
Результаты
Ещё несколько полезных функций
addServer — в случае, если у вас в распоряжении несколько кэширующих серверов, вы можете создать некий кластер, добавляя сервера в пул. Следует обратить внимание на параметр weight. Он указывает на то, сколько памяти вам будет доступно на конкретном сервере.
delete — из названия понятно, что данный метод удаляет из кэша объект с заданным ключом.
replace — заменяет значение объекта с заданным ключом. Используйте в случае, если Вам понадобится изменить содержимое объекта, раньше чем истечёт время его жизни.
С моей точки зрения, применять кэширование стоит только на высоконагруженных ресурсах. Ведь каждый раз, подключаясь к серверу Memcached, вы тратите драгоценное время, что скорее всего не будет оправданным. Что касается больших проектов, лучше сразу написать больше строк кода, чем потом делать это в попыхах, с мыслью о том, что ваш сервис лежит. Также не стоит забывать о расходовании памяти! Учтите, что положив 300 мегабайт в кэш, вы отняли у себя 300 мегабайт ОЗУ.
В завершение хочу сказать, что данная статья не раскрывает все прелести технологии, однако я надеюсь, что она стимулирует Вас к самосовершенствованию. Спасибо за прочтение, многоуважаемый %username%!
UPD: Ещё один интересный момент. Memcached, есть PHP API к libmemcached. А Memcache, библиотека для php, не использующая libmemcached.
1) Установил Memcache, а затем Memcached PHP Extension.
Какие оптимальные параметры нужно выставить в файле etc/sysconfig/memcached:
Если памяти на VPS:
На сайте, инструкцией которого я воспользовался, были следующие данные:
MAXCONN=»2048″ Максимальное количество подключений
CACHESIZE=»4096″ Количество фактической ОЗУ на сервере
И по аналогии я выставил MAXCONN = 25000, CACHESIZE = 50000. Правильно?
2) Как можно убедиться, что memcache и memcached PHP нормально все кешируют? Может команда есть для ssh или определенная директория, где можно посмотреть.
Заранее спасибо.
Параметры MAXCONN, CACHESIZE и OPTIONS подбираются экспериментальным путем в зависимости от характера нагрузки и от имеющихся ресурсов.
Оценить объем памяти, необходимой для кеширования (параметр CACHESIZE), можно по размеру вашего файлового кеша. Если у вас на проекте файловый кеш занимает 3 GB, то использование memcached c 256МБ памяти не будет эффективным за счет частого вытеснения.
Если же всю память отдать memcached, то остальным ничего не останется.
Универсального правила настройки нет.
Нужно просто понимать что это за числа:
MAXCONN - это примерно количество одновременных коннектов, которые отработает сервер в шт.
CACHESIZE - размер пространства в ОЗУ в МБ.
Поэтому узнайте сколько у вас свободной ОЗУ, прикиньте сколько можете выделить для memcached и пишите.
Почему-то я сомневаюсь что у вас на VPS 50Гб ОЗУ, поэтому прежде чем писать 50000 выясните этот момент.
Просто установленный и настроенный сервер memcached сам по себе ничего не кеширует.
Кеширование производится внутри приложения.
Вот там и посмотрите(установили кеш, прочитали кеш) если работает, значит работает "нормально")
Статья для новичков. Memcached – это такая штука для кэширования данных в оперативной памяти сервера.
Кэширование бывает разным. Самое простое — кэширование на файлах. Минус в том, что данные по-прежнему хранятся на диске, а это может привести к печальным последствиям. Можно кэшировать промежуточные результаты в базе (например, результаты поиска в некоторых форумных движках хранятся в базе). Ну и самое эффективное это конечно хранение в оперативной памяти. Для этого существует куча сторонних программ: Memcached, eAccelerator, APC, XCache. Кстати, MySQL тоже умеет хранить данные в своем кэше (речь не об индексах в памяти).
Вообще, пишут, что eAccelerator и XCache эффективней чем Memcached, если вы используете один сервер, так как в случае Memcached необходимо открывать TCP-соединение. Но у Memcached есть главное преимущество — это возможность разнесения данных по нескольким серверам. Например, кэш ЖЖ не уместится в памяти ни одного самого мощного сервера. Собственно, Memcached и был придуман для ЖЖ, чтобы можно было хранить данные на нескольких серверах. Но нам, новичкам, пока рано об этом думать.
Вытеснения
Когда Memcache доходит до ограничения в памяти, он начинает удалять объекты по принципу LRU. Количество удаленных объектов фиксируются в параметре evictions внутренней статистики:
Значение evictions должно быть нулевым либо очень небольшим. Большие значения – это сигнал для расширения. В таких случаях нужно проделать оптимизацию размеров чанков и слабов. После этого – устанавливать дополнительно оборудование.
Читайте также: