Compiladores Caché

Compiladores Caché - Sccache

Sumario

Introducción
Rust
Sccache
Configuración
Enlaces

Introducción

Sccache es un compilador caché, escrito con el lenguaje de programación, Rust, que puede llegar a acelerar hasta 10 veces la recompilación (esto implica también una instalación de versiones futuras del programa cacheado, pero con un mayor tiempo de compilación) de cualquier programa cuyo código fuente esté escrito en C , C++, Rust y CUDA. Su desarrollo está inspirado en Ccache, pero está más orientado a ser utilizado en compilaciones compartidas en red, lo que no impide que lo podamos utilizar de forma local. Tiene muchas menos opciones que Ccache, la compresión no es configurable, siendo el formato zip, el predefinido. La inclusión en la documentación de la web, viene determinada por su soporte de las compilaciones con Rust, cuya instalación como usuario a través de rustup, también se trata en este manual.

Rust

Descarga e Instalación de rustup

$ curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- --default-toolchain none -y

$ source ~/.bashrc

Configuración de Rustup para que no se instale la documentación de Rust

$ rustup set profile minimal

Instalar Rust en sus versiones de 64 y 32 bits (requerido este último para la compilación de la versión de 32 bits de Mesa)

$ rustup toolchain install stable-x86_64-unknown-linux-gnu

$ rustup target add i686-unknown-linux-gnu

Instalar Cargo-cache para reducir el tamaño de la instalación de Rust y ejecutarlo posteriormente

$ cargo install cargo-cache; cargo-cache -e

Cada vez que instalemos programas con Cargo, es conveniente ejecutar este programa, con su comando más agresivo 'cargo-cache -e', para reducir el tamaño que ocupa la instalación de Rust y sus componentes.

Actualizar la instalación de Rust cuando salga una nueva versión

$ rustup update

Mostrar los componentes instalados de Rust

$ rustup show

Directorio de instalación de Rust en nuestro directorio personal

~/.cargo

Sccache

Descarga

sccache-0.8.2.tar.gz

Extracción e Instalación como usuario

Instalaremos Sccache sin las opciones de red, ya que la finalidad de este manual, es que funcione como un compilador caché de forma local. Si queremos utilizar las opciones de caché compartida de forma remota, no añadir --no-default-features al comando de instalación.

$ tar zxvf sccache-0.8.2.tar.gz

$ cd sccache-0.8.2

$ cargo install --path . --no-default-features

Instalación como root

$ su

# mv /home/jose/.cargo/bin/sccache /usr/bin; chown root:root /usr/bin/sccache

# install -dm755 /usr/libexec/sccache

# for i in gcc g++ cc c++ clang clang++; do \

ln -f /usr/bin/sccache /usr/libexec/sccache/$i ; \

done

Explicación de los comandos

mv /home/jose/.cargo/bin /usr/bin; chown root:root /usr/bin/sccache : Mueve el binario creado como usuario a un directorio bin del sistema y cambia la propiedad al usuario root. Sustituir jose por el nombre de usuario de cada uno.

install -dm755 /usr/libexec/sccache: Crea el directorio de ubicación de los enlaces duros (sccache no admite enlaces simbólicos), cuya ubicación activaremos con el correspondiente alias global de bash.

for i in gcc g++ cc c++ clang clang++; do \
ln -f /usr/bin/sccache /usr/libexec/sccache/$i ; \
done : Crea los enlaces duros correspondientes relativos a GCC y Clang, apuntando al binario ejecutable sccache.

Creación de un alias global de Bash

Para activar Sccache, cuando lo creamos conveniente, creamos el alias global de Bash correspondiente, que instalaremos en /etc/profile.d.

# cat > sccache.sh << "EOF"

#!/bin/sh



alias scc="export PATH=/usr/libexec/sccache:$PATH"

EOF

# install -m755 sccache.sh /etc/profile.d

Ahora basta ejecutar scc, para activar el uso de Sccache:

$ scc

Para comprobar que estamos utilizando estos enlaces duros, nada mejor que utilizar el programa which, que se encarga de buscar el binario que le indiquemos previamente.

[jose@localhost ~]$ which gcc

/usr/libexec/sccache/gcc

En el caso de uso de Clang, basta establecer la correspondiente variable de entorno, al igual que hicieramos si no tuvieramos instalado Sccache.

$ export CC=clang CXX=clang++

Otra solución es utilizar directamente Sccache sin enlaces duros alguno, estableciendo las correspondientes variables de entorno de uso de compilador, antes de configurar un determinado paquete.

GCC

$ export CC="sccache gcc" CXX="sccache g++"

Clang

$ export CC="sccache clang" CXX="sccache clang++"

Estadísticas de Instalación de Sccache

Estadísticas de Instalación de Sccache
Archivos instalados	1
Archivos instalados	/usr/bin/sccache
Enlaces duros creados	6
Enlaces duros creados
Ocupación de espacio en disco	6,3 MB

Desinstalación como root

1) MODO TRADICIONAL

*********************

2) MODO MANUALINUX

sccache-0.8.2-scripts.tar.gz

$ su

# tar zxvf sccache-0.8.2-scripts.tar.gz

# cd sccache-0.8.2-scripts

# ./Desinstalar_sccache-0.8.2

Copia de Seguridad como root

Con este otro script creamos una copia de seguridad de los binarios compilados, recreando la estructura de directorios de los mismos en un directorio de copias de seguridad (copibin) que se crea en el directorio /var. Cuando se haya creado el paquete comprimido de los binarios podemos copiarlo como usuario a nuestro home y borrar el que ha creado el script de respaldo, teniendo en cuenta que si queremos volver a restaurar la copia, tendremos que volver a copiarlo al lugar donde se ha creado.

$ su

# tar zxvf sccache-0.8.2-scripts.tar.gz

# cd sccache-0.8.2-scripts

# ./Respaldar_sccache-0.8.2

Restaurar la Copia de Seguridad como root

Y con este otro script (que se copia de forma automática cuando creamos la copia de respaldo del programa) restauramos la copia de seguridad como root cuando resulte necesario.

$ su

# cd /var/copibin/restaurar_copias

# ./Restaurar_sccache-0.8.2

Configuración de Sccache

1) El directorio por defecto de ubicación de la caché
2) Establecer un directorio único de caché para todos los usuarios
3) Limpiar la caché
4) Establecer el tamaño máximo de la caché
5) Estadísticas de uso
6) Utilizar Sccache con Rust
7) Volver a almacenar una compilación determinada (sobrescribir la caché)
8) Saber en todo momento, qué hace Sccache

1) El directorio por defecto de ubicación de la caché

El directorio predefinido de ubicación de la caché de Sccache es el siguiente:

~/.cache/sccache

Y la ubicación del archivo de configuración es la siguiente:

~/.config/sccache/config

Tanto en nuestro directorio personal, como en el directorio del root, el tamaño máximo definido por defecto de la caché es de 10 GB. A diferencia de Ccache, Sccache no permite modificar las opciones de configuración desde línea de comandos y, por lo tanto, no crea en ningún momento el archivo de configuración del mismo, hay que crearlo a mano, con lo que, en este manual recurriremos a las variables de entorno para modificar las opciones del programa.

2) Establecer un directorio único de caché para todos los usuarios

La única condición que debe de tener este directorio es que sea accesible para lectura y escritura por todos los usuarios. La ventaja mayor es que nos ahorramos una duplicación de directorios, el del root y el nuestro propio. Lo primero que debemos de hacer es crear el directorio con los permisos correspondiente de acceso y escritura.

$ su -c "install -dm777 /.sccache"

Luego, movemos como usuario, el contenido de la caché ubicada en nuestro directorio personal, al nuevo directorio.

$ mv ~/.cache/sccache/* /.sccache

La que tengamos en el directorio del root, que siempre será de menor tamaño, simplemente la borramos.

$ su -c "rm -rf /root/cache/.sccache"

Editamos con cat el archivo que hemos creado antes e instalado en /etc/profile.d, sccache.sh y añadimos lo siguiente:

$ su

# cat >> /etc/profile.d/sccache.sh << "EOF"

export SCCACHE_DIR=/.sccache

EOF

3) Limpiar la caché

Sccache no tiene ninguna opción de limpieza de la caché, lo que deduzco que esta se limpia de forma automática cuando se llega al límite de la misma. En todo caso, como esto limita mucho su uso, incluyo la correspondiente función de Bash, que nos permitirá borrar la caché en función del rango de días que elijamos:

sccache-find-rm
() { find $SCCACHE_DIR -type f -newermt 20$3-$(echo $1 |
sed 's/^\([0-9]*\)\([^0-9]*\)\([0-9]*\)/\3\2\1/') ! -newermt
20$3-$(echo $2 | sed 's/^\([0-9]*\)\([^0-9]*\)\([0-9]*\)/\3\2\1/') |
xargs rm -f ; }

Si queremos borrar la caché del día 9 de febrero del año en curso, por ejemplo, ejecutamos lo siguiente:

$ sccache-find-rm 09-02 10-02 24

Donde 09-02 es la fecha de inicio de los archivos de la caché que se borrarán, 10-02 es el día siguiente que se establece como tope de borrado y, por último, 24 es el año en curso. Esto último nos permite borrar cachés del año anterior, cuando cambiamos a un año nuevo.

Editamos con cat el archivo que hemos creado antes e instalado en /etc/profile.d, sccache.sh y añadimos lo siguiente:

$ su

# cat >> /etc/profile.d/sccache.sh << "EOF"

sccache-find-rm
() { find $SCCACHE_DIR -type f -newermt 20$3-$(echo $1 |
sed 's/^\([0-9]*\)\([^0-9]*\)\([0-9]*\)/\3\2\1/') ! -newermt
20$3-$(echo $2 | sed 's/^\([0-9]*\)\([^0-9]*\)\([0-9]*\)/\3\2\1/') |
xargs rm -f ; }

EOF

Si queremos ver antes, si hay archivos en la caché de una determinada fecha, pero no queremos borrarlos, añadimos lo siguiente:

$ su

# cat >> /etc/profile.d/sccache.sh << "EOF"

sccache-find
() { find $SCCACHE_DIR -type f -newermt 20$3-$(echo $1 |
sed 's/^\([0-9]*\)\([^0-9]*\)\([0-9]*\)/\3\2\1/') ! -newermt
20$3-$(echo $2 | sed 's/^\([0-9]*\)\([^0-9]*\)\([0-9]*\)/\3\2\1/'); }

EOF

Con el comando sccache-find, nos mostrará todos los archivos incluidos en la caché en un determinado rango de días.

[jose@localhost ~]$ sccache-find 21-10 22-10 23

/mnt/cache4/.sccache/b/b/bbfe44e40a19a5b85464dd95f48a9601b4fd7c3251dd927d7f367c01d70fa244

/mnt/cache4/.sccache/b/b/bb03b079f4bad2405b4605dc50d2c06a782344e546b6131c0f32d4b1c1dfcd30

/mnt/cache4/.sccache/b/b/bbb738ceedc992c23bb598768080e67d1ccea7dca27d99c5f46fbbd074cd1691

/mnt/cache4/.sccache/b/2/b22ac1e0ea8e7bd3d1af98634e24ca20920c2646c97962c36365fc2d77d7f05c

/mnt/cache4/.sccache/b/2/b2752c3e55d9d30c0a1d1487dfe1c1195d6b1bb8bdf71f6deb4a083af2e9242c

4) Establecer el tamaño máximo de la caché

Con la variable de entorno SCCACHE_CACHE_SIZE, estableceremos el tamaño máximo de la caché. El predefinido es de 10 GB, si por ejemplo, queremos ponerlo en 40 GB, lo añadimos al archivo, sscache.sh:

$ su

# cat >> /etc/profile.d/sccache.sh << "EOF"

export SCCACHE_CACHE_SIZE=40G

EOF

5) Estadísticas de uso

Como cualquier aplicación caché que se precie, Sccache también nos muestra estadísticas de uso, pero a diferencia de Ccache, no las almacena de forma local. Sólo nos mostrará las estadísticas de la compilación en curso y hasta que, el demonio del programa, cese su actividad a los 10 minutos de ejecutarlo. Esto último se puede desactivar pero no es necesario, porque no supone ninguna carga para el sistema.

[jose@localhost ~]$ sccache -s

Compile
requests                   
242

Compile requests executed           186

Cache
hits                          
35

Cache hits
(C/C++)                  
35

Cache
misses                       
149

Cache misses (Rust)                 149

Cache
timeouts                       
0

Cache read
errors                    
0

Forced
recaches                      
0

Cache write
errors                   
0

Compilation failures                  0

Cache
errors                         
2

Cache errors
(Rust)                  
2

Non-cacheable compilations            0

Non-cacheable calls                  51

Non-compilation calls                 5

Unsupported compiler calls            0

Average cache write               0.001 s

Average compiler                  0.860 s

Average cache read hit            0.000 s

Failed distributed compilations       0



Non-cacheable reasons:

crate-type                          
39

-                                    
7

unknown source language               5



Cache
location                 
Local disk: "/mnt/cache4/.sccache"

Use direct/preprocessor mode?   yes

Version (client)                0.7.2

Cache
size                         
742 MiB

Max cache
size                      
40 GiB

Para poner a cero las estadísticas, ejecutamos el siguiente comando:

$ sccache -z

6) Utilizar Sccache con Rust

Para que Sccache, almacene las compilaciones de Rust, añadimos lo siguiente al archivo, sccache.sh:

$ su

# cat >> /etc/profile.d/sccache.sh << "EOF"

export RUSTC_WRAPPER=/usr/bin/sccache

EOF

7) Volver a almacenar una compilación determinada (sobrescribir la caché)

Para que Sccache, vuelva a almacenar desde cero una determinada compilación, añadimos lo siguiente al archivo, sccache.sh:

$ su

# cat >> /etc/profile.d/sccache.sh << "EOF"

alias scr="export SCCACHE_RECACHE=true"

alias noscr="export SCCACHE_RECACHE=false"

EOF

Con scr activamos que se vuelva a almacenar desde cero una determinada compilación, y con noscr lo desactivamos.

8) Saber en todo momento, qué hace Sccache

Esto es útil para comprobar cómo se comporta Sccache en el proceso de compilación. Nos permite también averiguar errores del mismo. Con la correspondiente variable de entorno, establecemos un archivo de registro de las tareas que realiza el programa. Como no es nada recomendable que lo haga por defecto, porque como es lógico, añade una sobrecarga al mismo, nos creamos un alias de bash, para utilizarlo cuando lo creamos oportuno y lo añadimos al final del archivo que estamos utilizando para configurar el programa:

$ su

# cat >> /etc/profile.d/sccache.sh << "EOF"

alias sccl="export SCCACHE_ERROR_LOG=$HOME/sccache.log SCCACHE_LOG=debug"

alias nosccl="export SCCACHE_ERROR_LOG= SCCACHE_LOG=; rm -f $HOME/sccache.log"

EOF

Con sccl activamos el archivo de registro en la raíz de nuestro directorio personal, con el nombre sccache.log y con noccl lo desactivamos y borramos el archivo creado.

Enlaces

https://github.com/mozilla/sccache >> Enlace al proyecto del programa en GitHub.