Script para controlar la Memoria Cache en GNU/Linux

Recientemente en GUTL hemos estado comentando algunos de los problemas relativos a la gestión de la memoria cache en Linux, particularmente en Debian. En algunas ocasiones mi portátil llegaba al punto del colapso, no tenía más remedio que liberar la memoria cache manualmente, y en casos extremos: reiniciaba el sistema. Esto es debido a que cuando tenemos muchas aplicaciones abiertas, aunque cerremos una buena parte de ellas, estas quedan en la memoria ram (cache). La próxima vez que las abramos tardarán mucho menos en ejecutarse.

Memoria caché:

Área de almacenamiento dedicada a los datos usados o solicitados con más frecuencia para su recuperación a gran velocidad.

Sin embargo, lo que debería ser una ventaja, en ocasiones supone un problema. En máquinas de bajos recursos cuando necesitamos iniciar otras aplicaciones, es probable que no dispongan de la suficiente memoria ram para ejecutarse de manera fluida. Para ello es necesario liberar la memoria cache ejecutando el siguiente comando: sync; echo 3 > /proc/sys/vm/drop_caches.

Hay varias formas de gestionar esta tarea mediante la creación de scripts. Aquí en el portal GUTL hay buena información al respecto: liberando memoria ram desde la terminal o consola y como limpiar los caches de memoria en gnulinux.

Personalmente suelo utilizar un script muy pequeño para facilitar esta tarea. En resumidas cuentas:

Contenido del archivo: limpiar-cache.sh

#!/bin/sh

sync && echo 3 > /proc/sys/vm/drop_caches 

permisos de ejecución y carpeta destino:

sudo chmod +x limpiar-cache.sh

sudo cp limpiar-cache.sh /usr/local/bin

Invocando: limpiar-cache.sh desde la consola mitigaba el problema. También supe hacer uso del comando crontab para prescindir de la terminal, y que el script se ejecutara cada cierto tiempo. El problema es que en muchos casos limpiaba la cache cuando no lo necesitaba, y en otras ocasiones, estaba expectante a que crontab hiciera su trabajo. Esta idea no me daba el resultado que yo deseaba, volví al método manual. Cabe aclarar que ahora sería factible su uso.

Finalmente —a raíz de un comentario de Pablo (@elMor3no)— me decidí a crear un script automatizado muy sencillo, que tenga parámetros preestablecidos, y en función de estos, realice la tarea sin mi intervención. Se trata de un bucle infinito, pero no hay de que preocuparse, no consume nada. Básicamente el script sera gestionado por systemd. Aunque no soy un gran admirador de este, admito que tiene sus cosas buenas: como lo práctico.

El script

El script con permisos de ejecución está alojado en la ruta /root/scripts/, no obstante, podría estar alojado en otra ruta, como: /usr/local/bin.

sudo chmod +x control-cache.sh
sudo mkdir /root/scripts
sudo cp control-cache.sh /root/scripts

Archivo: /root/scripts/control-cache.sh

#!/bin/sh

# Control de la Memoria Cache

memoria_minima=300
tiempo_espera=15

while true; do

free_memory=`free -m | grep Mem | awk '{print $4}'`

    if [ $free_memory -le $memoria_minima ]; then

        sync; echo 3 > /proc/sys/vm/drop_caches

    fi

    sleep $tiempo_espera

done

Descargar control-cache.sh

Una breve descripción de su función

memoria_minima: Aquí se define el piso mínimo (umbral) en donde queremos que comience a liberase memoria cache. En este caso está fijado en 300MB de memoria ram disponible.

tiempo_espera: Este valor es importante, y establece el tiempo que tardará en volver a ejecutarse el bucle (while) finalizada la última sentencia. Es tarea del usuario establecer un valor razonable.

free_memory: Esta variable guarda el estado actual de la memoria ram disponible, dicho valor será comparado con la memoria mínima asignada por el usuario (umbral). El tiempo entre cada comparación está determinado por la sentencia: sleep $tiempo_espera

Obtención del valor free_memory utilizando grep y awk para filtrar:

En la próxima linea empleo una condicional (if): «Si la memoria (free) disponible es menor o igual que el valor mínimo asignado por el usuario» ejecutar la próxima sentencia: sync; echo 3 > /proc/sys/vm/drop_caches. Seguidamente, se haya cumplido o no la condición, espera el tiempo establecido por el usuario, y vuelve a ejecutarse el ciclo. De acuerdo con estos valores, cuando la memoria ram disponible toque el piso de los 300MB: libera la cache, espera 15 segundos, y vuelve a iniciar el ciclo de comprobación.

El tiempo de espera (sleep) es particularmente importante porque de otra forma aumentaría los ciclos de la cpu. Además, cuando perfore el piso mínimo —300MB en este caso—, de mantenerse por un tiempo, por ej.: en 285MB – 290MB, se estará ejecutando: sync; echo 3 > /proc/sys/vm/drop_caches hasta leer un valor superior a 300MB, en el cual se detendrá. En este hipotético caso se estaría liberando memoria cada 15 segundos, por lo tanto, un tiempo razonable sería de 30 a 60 segundos, aunque con 15 seg. se desempeñó bastante bien. Depende de cada uno establecer ese valor, al igual que el piso mínimo de la memoria ram.

Archivo de unidad (systemd)

Llegó el momento de gestionar el script control-cache.sh como un servicio. Con privilegios root edité el archivo de unidad control-cache.service en el directorio /etc/systemd/system/. A este archivo no hay que asignarle permisos de ejecución.

Contenido del archivo: /etc/systemd/system/control-cache.service

[Unit]
Description=Control de la Memoria Cache

[Service]
Type=simple
ExecStart=/root/scripts/control-cache.sh
WorkingDirectory=/root/scripts
Restart=on-failure
StandardOutput=syslog
StandardError=syslog

[Install]
WantedBy=multi-user.target

Descargar control-cache.service

No hay mucho que decir, es un archivo de unidad bastante simple de entender:

Type=simple: es el servicio por defecto, debe iniciarse inmediatamente, además el proceso no debe romperse. No utilizar este tipo si otros servicios tienen que ser llamados por ese servicio, a menos que no sea activado por el socket.

ExecStart=: como su nombre lo indica, es el encargado de ejecutar el script en la ruta establecida.

WorkingDirectory=: directorio de trabajo, generalmente el mismo donde se aloja la aplicación (script).

Restart=on-failure=: reinicia el servicio en caso de fallar.

StandardOutput=: salida estándar de los registros (log), si no se especifica nada, por defecto escribirá en el archivo /var/log/syslog. En caso de especificarse null, redirige los registros a /dev/null.

StandardError=: ídem al anterior para casos de error.

WantedBy=multi-user.target=: es el análogo al nivel 3 en SystemV, y permite habilitar el script para que se inicie en el arranque del sistema.

Habilitar el archivo de servicio

Una vez que tengamos ambos archivos en sus respectivas rutas: /root/scripts/control-cache.sh y /etc/systemd/system/control-cache.service, es momento de manipular el servicio mediante los siguientes comandos:

Arranque, parada y reinicio:

sudo systemctl start control-cache.service

sudo systemctl stop control-cache.service

sudo systemctl restart control-cache.service

verificar que haya iniciado correctamente:

sudo systemctl status control-cache.service

Si todo ha ido bien, podemos habilitarlo en el arranque:

sudo systemctl enable control-cache.service

La siguiente imagen muestra el servicio en estado habilitado en el inicio del sistema y activo:

También es posible controlarlo con los siguientes comandos:

sudo service control-cache start | stop | status

Testear el script

Para asegurarte de que el script se adapta a tus exigencias, o simplemente quieres saber como se comporta, puedes realizar algunas pruebas de estrés de la siguiente forma: en 3 terminales, o una sola terminal dividida en 3 ventanas (tmux, terminator), en lo posible elige la opción «Siempre encima» para que no pierdan el foco. En cada una escribir el siguiente comando:

• Terminal 1: watch free -m
• Terminal 2: tail -f /var/log/syslog
• Terminal 3: htop

Antes de abrir aplicaciones, chequear en htop (terminal 3) que los ciclos de cpu están bien. A continuación observando la memoria libre disponible (terminal 1), comienza a abrir aplicaciones hasta aproximarse al umbral que escogiste, supongamos: 300MB, e intenta perforar ese piso por unos pocos megas —digamos 280, 295—. El tiempo de respuesta estará dado entre: 1 seg. y el tiempo de espera que seleccionaste (ej.: 15 seg.). Observa el registro de syslog (terminal 2) y comprueba que el script está respondiendo.

Luego prueba mantener aplicaciones abiertas, a tal punto, que no pueda superar el techo de los 300MB. Observa el registro syslog y verifica que el tiempo de espera para limpiar la memoria cache, en repeticiones consecutivas, es el que se ajusta a tus necesidades. No descuidar Htop.

Consideraciones finales

También es posible automatizar esta tarea mediante crontab —aunque personalmente, a modo de gestionar el script, prefiero systemd—. Por ejemplo, realizar una tarea cada 30 segundos todos los días: 30 * * * * /root/scripts/control-cache.sh. En este caso el script solo debe contar con la linea de comprobación, el ciclo lo realiza crontab:

#!/bin/sh

# Control de la Memoria Cache

memoria_minima=300

free_memory=`free -m | grep Mem | awk '{print $4}'`

    if [ $free_memory -le $memoria_minima ]; then

        sync; echo 3 > /proc/sys/vm/drop_caches

    fi

El script no hace magia, y lamentablemente tampoco gestiona la ram, eso es tarea del sistema. control-cache.sh simplemente intenta otorgarle independencia al usuario, para que no tenga que estar todo el tiempo expectante. Espero que a alguien le sea utilidad.

Fuente:

https://wiki.archlinux.org/index.php/Systemd_(Español)#Tipos_de_servicios

Artículos relacionados con lo que acabas de leer:

• [Actualización] Monitorear el rendimiento de nuestro sistema en Linux con Netdata
• NeoFetch, una forma fácil de encontrar la información de tu sistema
• Monitorear el rendimiento de nuestro sistema en Linux con Netdata (front-end Web)
• De REPOGUTL: «scripts»
• Jugando con Bash y nuestra unidad de CD/DVD

Publicado por Percaff_TI99

http://gutl.jovenclub.cu/ » Forma parte de GUTL desde el 10 agosto, 2013. Amante de la ciencia y tecnología en general. Usuario de GNU/Linux desde hace varios años.