Manualinux
http://www.nvu.com http://www.gimp.org InicioPresentaciónActualizacionesManualesDescargasNoticiasAgradecimientoEnlaces

Entornos GráficosAplicaciones

DesarrolloEmuladoresInternetJuegosMultimediaSistema

Compiladores Caché - F90cache

Compiladores Caché - Ccache




Compiladores Caché - Ccache



Copyright

Copyright © José Luis Lara Carrascal  2008-2024   http://manualinux.es


Sumario

Introducción
Instalación
Configuración
Enlaces

 
Introducción

Ccache es un compilador caché 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++, Objetive-C y Objetive-C++. La forma de trabajar de Ccache consiste en detectar si el código que se está compilando es el mismo que se ha compilado anteriormente. Para ello utiliza el algoritmo de resumen (hash) MD4, para obtener la información en función del modo utilizado por Ccache, que pueden ser los siguientes:

1) Modo direct (el predefinido) : Ccache hashea el código fuente e incluye los archivos de forma directa. El hash contiene la información común y:

* Los archivos de código fuente de entrada.
* Las opciones de línea de comandos.

Resumiendo, si el archivo objeto y la salida del preprocesador no han cambiado, se utiliza este modo.

2) Modo preprocessor (más lento) : Ccache ejecuta el preprocesador en el código fuente y hashea el resultado. El hash contiene la información común y:

* La información de salida del preprocesador cuando el compilador se está ejecutando con la opción -E.
* Las opciones de línea de comandos excepto las que afectan a los archivos incluidos (-I, -include, -D, etc.).
* Toda la información de salida estándar de errores (stderr) generada por el preprocesador.

Resumiendo, si el archivo objeto ha cambiado pero la salida del preprocesador es la misma, se utiliza este modo, más lento que el anterior.

3) Modo depend : Ccache no utiliza nunca el preprocesador funcionando siempre en modo direct. Esto provoca que la tasa de aciertos sea más baja. Este modo no es compatible con la opción run_second_cpp=false (export CCACHE_NOCPP2=true).

En este manual trataremos su instalación desde código fuente y su configuración para que todos los procesos de compilación que llevemos a cabo en nuestro sistema sean cacheados por Ccache.


Instalación

Dependencias

Herramientas de Compilación

Entre paréntesis la versión con la que se ha compilado Ccache para la elaboración de este documento.

* GCC - (14.1.0) o Clang - (18.1.8)
* CMake - (3.30.1)
* Ninja - (1.12.1)

Librerías de Desarrollo

* Hiredis - (1.2.0)
* Libfmt - (11.0.2)
* Libxxhash - (0.8.2)
* Libzstd - (1.5.6)

Aplicaciones

* Asciidoctor - (2.0.23) [1]

[1] Requerido para poder generar la documentación del programa, que no se instala con el mismo.


Descarga

ccache-4.10.2.tar.xz

Optimizaciones

$ export {C,CXX}FLAGS='-O3 -march=znver3 -mtune=znver3'

Donde pone znver3 se indica el procesador respectivo de cada sistema seleccionándolo de la siguiente tabla:
Nota informativa sobre las optimizaciones para GCC
* La opción '-march=' establece el procesador mínimo con el que funcionará el programa compilado, la opción '-mtune=' el procesador específico para el que será optimizado. 

* Los valores separados por comas, son equivalentes, es decir, que lo mismo da poner '-march=k8' que '-march=athlon64'.

* En versiones de GCC 3.2 e inferiores se utiliza la opción '-mcpu=' en lugar de '-mtune='.
Nota informativa sobre las optimizaciones para Clang
* La opción '-mtune=' está soportada a partir de la versión 3.4 de Clang.

* Los valores de color azul no son compatibles con Clang.

* Las filas con el fondo de color amarillo son valores exclusivos de Clang y, por lo tanto, no son aplicables con GCC.
Valores CPU
Genéricos
Intel
AMD

Optimizaciones adicionales

Optimizaciones adicionales
GCC
Graphite
$ export {C,CXX}FLAGS+=' -ftree-loop-linear -floop-strip-mine -floop-block'
IPA
$ export {C,CXX}FLAGS+=' -fipa-pta'
LTO
$ export {C,CXX}FLAGS+=' -fuse-linker-plugin -flto=auto'
En versiones inferiores a GCC 10, sustituir auto por el número de núcleos que tenga nuestro procesador. Si sólo tiene uno, utilizar el parámetro -flto
PGO
1) Fase inicial de compilación e instalación del paquete.
$ export {C,CXX}FLAGS+=' -O2 -fprofile-generate=/var/pgo/ccache'
Configurar el paquete con la opción -DCMAKE_BUILD_TYPE=Debug
2) Ejecutar 'ninja -C build test -j$(nproc)' en el directorio raíz del paquete.
3) Fase final de compilación e instalación del paquete.
$ export {C,CXX}FLAGS+=' -fprofile-use=/var/pgo/ccache'
Clang
Polly
$ export {C,CXX}FLAGS+=' -O3 -mllvm -polly -mllvm -polly-vectorizer=stripmine'
LTO
$ export {C,CXX,LD}FLAGS+=' -flto'
ThinLTO
$ export {C,CXX,LD}FLAGS+=' -flto=thin'
La aplicación de esta optimización es alternativa a la tradicional LTO, a partir de Clang 3.9 y, por lo tanto, no es combinable con la misma.
Unified LTO
LTO >> ThinLTO
$ export {C,CXX}FLAGS+=' -flto -funified-lto'
$ export LDFLAGS+=' -Wl,--lto=thin'
ThinLTO >> LTO
$ export {C,CXX}FLAGS+=' -flto=thin -funified-lto'
$ export LDFLAGS+=' -Wl,--lto=full'
La aplicación de esta optimización es aplicable, a partir de Clang 17, y sólo es combinable con LLD.
PGO
1) Fase inicial de compilación e instalación del paquete.
$ export {C,CXX}FLAGS+=' -O2 -fprofile-generate=/var/pgo/ccache'
Configurar el paquete con la opción -DCMAKE_BUILD_TYPE=Debug
2) Ejecutar 'ninja -C build test -j$(nproc)' en el directorio raíz del paquete.
3) Conversión del perfil de optimización a un formato legible por Clang.
$ PGODIR=/var/pgo/ccache; llvm-profdata merge $PGODIR/default_*.profraw --output=$PGODIR/default.profdata
4) Fase final de compilación e instalación del paquete.
$ export {C,CXX}FLAGS+=' -fprofile-use=/var/pgo/ccache'

Parámetros adicionales

Parámetros adicionales de eliminación de avisos en el proceso de compilación
$ export {C,CXX}FLAGS+=' -w'

Establecer la ruta de búsqueda de directorios de librerías en sistemas de 64 bits multiarquitectura
$ export LDFLAGS+=" -L/usr/lib64 -L/usr/local/lib64 -L/opt/gcc14/lib64"
Cada usuario tendrá que establecer la ruta de búsqueda de directorios, en función de la distribución que utilice.

Establecer el uso de enlazador dinámico para Mold
$ export LDFLAGS+=' -fuse-ld=mold'

Establecer el uso de enlazador dinámico para LLD
Clang
$ export LDFLAGS+=' -fuse-ld=lld'
Optimizaciones complementarias LTO/ThinLTO/PGO de LLD
$ export LDFLAGS+=' -Wl,--lto-aa-pipeline=globals-aa -Wl,--lto-newpm-passes=pgo-memop-opt'
Optimizaciones complementarias LTO de LLD
$ export LDFLAGS+=" -Wl,--lto-partitions=$(expr $(nproc) / 2)"
Optimizaciones complementarias ThinLTO de LLD
$ export LDFLAGS+=" -Wl,--thinlto-jobs=$(expr $(nproc) / 2)"

Establecer la variable de entorno de uso de compilador para Clang
$ export CC=clang CXX=clang++

Extracción y Configuración  Bloc de Notas Información general sobre el uso de los comandos

$ tar Jxvf ccache-4.10.2.tar.xz
$ cd ccache-4.10.2
$ cmake -S . -B build -DCMAKE_INSTALL_PREFIX=/usr -DENABLE_TESTING=OFF -G Ninja

Explicación de los comandos

-S . -B build : Establece el directorio del código fuente y crea de forma automática el directorio de compilación.

-DCMAKE_INSTALL_PREFIX=/usr : Instala el programa en el directorio principal, /usr.

-DENABLE_TESTING=OFF : Desactiva la compilación de los tests que contiene el paquete. No añadir esta opción en la fase inicial de la optimización PGO.

-G Ninja : Utiliza Ninja en lugar de GNU Make para compilar el paquete (opcional).

Compilación

$ ninja -C build

Parámetros de compilación opcionales

-v : Muestra más información en el proceso de compilación.

-j$(nproc) : Establece el número de procesos de compilación en paralelo, en función del número de núcleos e hilos que tenga nuestro procesador, tomando como referencia la información mostrada por el sistema con el comando correspondiente. Si nuestro procesador es mononúcleo de un solo hilo, no añadir esta opción.

Instalación como root

$ su
# ninja -C build install/strip
# install -dm755 /usr/libexec/ccache
# for i in gcc g++ cc c++ clang clang++; do \
ln -s /usr/bin/ccache /usr/libexec/ccache/$i ; \
done

Explicación de los comandos

install -dm755 /usr/libexec/ccache : Crea el directorio de ubicación de los enlaces simbólicos, cuya ubicación activaremos con el correspondiente alias global de bash, para evitar problemas, si tenemos instalado también BuildCache.

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

Creación de un alias global de Bash

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

# cat > ccache.sh << "EOF"
#!/bin/sh

alias cca="export PATH=/usr/libexec/ccache:$PATH"
EOF
# install -m755 ccache.sh /etc/profile.d

Ahora basta ejecutar cca, para activar el uso de Ccache:

$ cca

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

[jose@localhost ~]$ which gcc
/usr/libexec/ccache/gcc

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

$ export CC=clang CXX=clang++

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

GCC
$ export CC="ccache gcc" CXX="ccache g++"

Clang
$ export CC="ccache clang" CXX="ccache clang++"

Este método da problemas con CMake 3.27 (no en todos los paquetes) y parece ser que, en las compilaciones de módulos de Python también. Digo parece ser, porque en mi caso personal, todo lo relacionado con Python se compila con GCC. Con el enlace simbólico relativo a Clang, también da problemas en algunos paquetes que usan CMake.

Estadísticas de Compilación e Instalación de Ccache

Estadísticas de Compilación e Instalación de Ccache
CPU AMD Ryzen 5 5500
MHz 3600 (BoostMax=4457)
RAM 32 GB
Sistema de archivos XFS
Versión del Kernel 6.10.0-ml SMP PREEMPT_DYNAMIC x86_64
Modo de frecuencia de la CPU powersave (balance performance)
Planificador de CPU BMQ
Versión de Glibc 2.40
Enlazador dinámico LLD 18.1.8
Compilador Clang 18.1.8
Parámetros de optimización -03 -march=znver3 -mtune=znver3 -mllvm -polly -mllvm -polly-vectorizer=stripmine -flto -funified-lto -fprofile-use=/var/pgo/ccache -Wl,--lto=thin -Wl,--thinlto-jobs=6 -Wl,--lto-aa-pipeline=globals-aa -Wl,--lto-newpm-passes=pgo-memop-opt
Parámetros de compilación -v -j12
Tiempo de compilación 13"
Archivos instalados 2
Mostrar/Ocultar la lista de archivos instalados
Enlaces simbólicos creados 6
Mostrar/Ocultar la lista de enlaces simbólicos creados
Ocupación de espacio en disco 1,4 MB

Desinstalación como root

1) MODO TRADICIONAL

Este programa no tiene soporte para desinstalación con el comando 'ninja uninstall'

2) MODO MANUALINUX

El principal inconveniente del comando anterior es que tenemos que tener el directorio de compilación en nuestro sistema para poder desinstalar el programa. En algunos casos esto supone muchos megas de espacio en disco. Con el paquete de scripts que pongo a continuación logramos evitar el único inconveniente que tiene la compilación de programas, y es el tema de la desinstalación de los mismos sin la necesidad de tener obligatoriamente una copia de las fuentes compiladas.

ccache-4.10.2-scripts.tar.gz

$ su
# tar zxvf ccache-4.10.2-scripts.tar.gz
# cd ccache-4.10.2-scripts
# ./Desinstalar_ccache-4.10.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 ccache-4.10.2-scripts.tar.gz
# cd ccache-4.10.2-scripts
# ./Respaldar_ccache-4.10.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_ccache-4.10.2


Configuración de Ccache  

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) Estadísticas de uso
5) Uso de otras versiones de GCC con Ccache
6) Desactivar el uso de Ccache
7) Volver a almacenar una compilación determinad (sobrescribir la caché)
8) Hacer que Ccache almacene las cabeceras precompiladas (PCH)
9) Cambiar la ubicación de los archivos temporales de Ccache en sistemas con Tmpfs montado en /tmp
10) Acelerar ligeramente el uso de Ccache modificando el funcionamiento del preprocesador
11) Desactivar la compresión de la caché de Ccache
12) Mostrar las opciones en curso de Ccache
13) Soporte de enlaces de referencia (reflinks) en sistemas de archivos como XFS y BTRFS
14) Activar el almacenamiento en caché de hashes de archivo según el dispositivo, el inodo y las marcas de tiempo
15) Reducir el nivel de compresión de la caché de Ccache
16) Saber en todo momento, qué hace Ccache
17) Obtener las estadísticas de un proceso de compilación concreto
18) Utilizar un segundo directorio adicional como caché

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

A partir de la versión 4.0 de Ccache, la ubicación predefinida del directorio de la caché se ha modificado. Por defecto es la siguiente:

~/.cache/ccache

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

~/.config/ccache/ccache.conf

Tanto en nuestro directorio personal, como en el directorio del root, el tamaño máximo definido por defecto de la caché es de 5 GB, tamaño que podemos modificar desde la línea de comandos, con el siguiente comando, un ejemplo estableciéndola en 500 MB.

[jose@localhost ~]$ ccache -M 500M
Set cache size limit to 512000k

También podemos utilizar G (para GB) y K (para KB), otro ejemplo, esta vez la pongo en 2 GB.

[jose@localhost ~]$ ccache -M 2G
Set cache size limit to 2097152k

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 /.ccache"

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

$ mv ~/.ccache/* /.ccache

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

$ su -c "ccache -C"

Editamos el archivo ccache.sh que hemos creado en la instalación del programa y añadimos lo que está en rojo:

#!/bin/sh

alias cca="export PATH=/usr/libexec/ccache:$PATH"
export CCACHE_DIR=/.ccache
export CCACHE_UMASK=000

Mi recomendación personal es utilizar un directorio en otro disco duro y, a ser posible, en una partición XFS o EXT4, dado el mínimo nivel de fragmentación que poseen estos sistemas de archivos. Un tamaño de 15 o 20 GB no es nada descabellado, si tenemos pensado utilizar Ccache por defecto para compilar todos los paquetes de código fuente. 

3) Limpiar la caché  

Para ajustar el tamaño de la caché al máximo establecido en su configuración, ejecutamos el siguiente comando, aunque esto no es necesario hacerlo ya que el programa lo hace de forma automática.

$ ccache -c

Para borrarla por completo, el siguiente:

$ ccache -C

La caché de versiones anteriores a la 4.0, de Ccache, no es compatible con ésta. Tendremos que ejecutar el siguiente comando para borrar tanto la caché como las estadísticas de uso de la misma.

$ ccache -C -z

4) Estadísticas de uso

Como cualquier aplicación caché que se precie, Ccache también nos muestra estadísticas de uso, con el siguiente comando (comando que se ha modificado a partir de la versión 4.4 del programa):

4a) Muestra las estadísticas de forma reducida:

[jose@localhost ~]$ ccache -s
Cacheable calls:   483183 / 858219 (56.30%)
  Hits:            346826 / 483183 (71.78%)
    Direct:        237696 / 346826 (68.53%)
    Preprocessed:  109130 / 346826 (31.47%)
  Misses:          136357 / 483183 (28.22%)
Uncacheable calls: 375025 / 858219 (43.70%)
Errors:                11 / 858219 ( 0.00%)
Local storage:
  Cache size (GB):  10.86 /  30.00 (36.20%)
  Cleanups:             1

4b) Muestra más información en las estadísticas de uso del programa

[jose@localhost ~]$ ccache -sv
Cache directory:                    /mnt/cache/.ccache
Config file:                        /mnt/cache/.ccache/ccache.conf
System config file:                 /etc/ccache.conf
Stats updated:                      Fri Oct 21 17:54:14 2022
Cacheable calls:                     483183 / 858219 (56.30%)
  Hits:                              346826 / 483183 (71.78%)
    Direct:                          237696 / 346826 (68.53%)
    Preprocessed:                    109130 / 346826 (31.47%)
  Misses:                            136357 / 483183 (28.22%)
Uncacheable calls:                   375025 / 858219 (43.70%)
  Autoconf compile/link:              63110 / 375025 (16.83%)
  Bad compiler arguments:              7649 / 375025 ( 2.04%)
  Called for linking:                114673 / 375025 (30.58%)
  Called for preprocessing:           56364 / 375025 (15.03%)
  Compilation failed:                 16441 / 375025 ( 4.38%)
  Compiler produced empty output:      5428 / 375025 ( 1.45%)
  Compiler produced no output:            9 / 375025 ( 0.00%)
  Could not use precompiled header:     408 / 375025 ( 0.11%)
  Forced recache:                     56730 / 375025 (15.13%)
  Multiple source files:                147 / 375025 ( 0.04%)
  No input file:                      32505 / 375025 ( 8.67%)
  Output to stdout:                     145 / 375025 ( 0.04%)
  Preprocessing failed:               13225 / 375025 ( 3.53%)
  Unsupported code directive:           172 / 375025 ( 0.05%)
  Unsupported compiler option:         7950 / 375025 ( 2.12%)
  Unsupported source language:           69 / 375025 ( 0.02%)
Errors:                                  11 / 858219 ( 0.00%)
  Internal error:                        11 /     11 (100.0%)
Successful lookups:
  Direct:                            237696 / 516035 (46.06%)
  Preprocessed:                      109130 / 324106 (33.67%)
Local storage:
  Cache size (GB):                    10.86 /  30.00 (36.20%)
  Files:                             318655
  Cleanups:                               1
  Hits:                                   0
  Misses:                                 0
  Reads:                            1078911
  Writes:                                 0

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

$ ccache -z

5) Uso de otras versiones de GCC con Ccache

Además de leernos el correspondiente manual acerca de la instalación de otras versiones de GCC en nuestro sistema, la forma de hacer funcionar Ccache con otras versiones de GCC es muy simple, ejecutando la correspodiente variable de entorno, un ejemplo:

$ export CCACHE_COMPILER=gcc34

Ahora ejecutamos gcc --version y comprobamos que nos sale la versión que le hemos pasado mediante la variable de entorno anteriormente ejecutada.

[jose@localhost ~]$ gcc --version
gcc34 (GCC) 3.4.6
Copyright (C) 2006 Free Software Foundation, Inc.
Esto es software libre; vea el código para las condiciones de copia.  NO hay
garantía; ni siquiera para MERCANTIBILIDAD o IDONEIDAD PARA UN PROPÓSITO EN
PARTICULAR

Tener en cuenta que el nombre del ejecutable del compilador (en este caso gcc34) no aparecerá nunca en los mensajes que se muestren en el proceso de compilación, ya que estamos utilizando como puente a Ccache y los pertinentes enlaces simbólicos que hemos creado.

6) Desactivar el uso de Ccache

Esto es útil si por ejemplo, queremos saber el tiempo real de compilación de un paquete determinado. Con la siguiente variable de entorno, Ccache actuará como un simple intermediario sin almacenar dato alguno del proceso de compilación en curso.

$ export CCACHE_DISABLE=true

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

La siguiente variable de entorno es similar a la anterior, en lo que respecta al tiempo real de compilación. La diferencia radica en que en este caso, sí se almacenan los datos del proceso de compilación en curso, empezando desde cero, y sobrescribiendo los que hubiera en la caché relativos al paquete en cuestión.

$ export CCACHE_RECACHE=true

8) Hacer que Ccache almacene las cabeceras precompiladas (PCH)  

Cuando utilizamos Ccache por primera vez, comprobaremos en las estadísticas del mismo que aparece una sección denominada can't use precompiled header que se va llenando a medida que vamos compilando paquetes. Para evitar esto y hacer que este tipo de cabecera que se genera en algunos procesos de compilación sea también almacenada por Ccache, ejecutamos el siguiente comando de modificación de la configuración de Ccache en la ventana de terminal:

$ ccache -o sloppiness=time_macros,pch_defines,include_file_mtime,include_file_ctime

Que tendremos que combinar con los parámetros de compilación que le pasaremos a cualquiera de los dos compiladores que usemos, GCC o Clang:

GCC
$ export {C,CXX}FLAGS+=' -fpch-preprocess'

Clang
$ export {C,CXX}FLAGS+=' -Xclang -fno-pch-timestamp'

Reseñar también que el almacenamiento de las cabeceras precompiladas hace que la caché se llene mucho antes, dado el tamaño de algunos de estos archivos.

9) Cambiar la ubicación de los archivos temporales de Ccache en sistemas con Tmpfs montado en /tmp  

En sistemas que utilicen el sistema de archivos, Tmpfs para ubicar los archivos temporales en /tmp, es recomendable que los archivos temporales creados por Ccache se almacenen en este directorio, y no, en el directorio de ubicación de la caché. La escritura de los archivos temporales en la memoria física del sistema siempre será más rápida que la escritura en un disco duro, por muy rápido que sea éste.

Para modificar esto, editamos el archivo que hemos creado anteriormente, ccache.sh y añadimos lo siguiente, lo que está en rojo:

#!/bin/sh

alias cca="export PATH=/usr/libexec/ccache:$PATH"
export CCACHE_DIR=/.ccache
export CCACHE_UMASK=000
export CCACHE_TEMPDIR=/tmp

10) Acelerar ligeramente el uso de Ccache modificando el funcionamiento del preprocesador  

El uso de esta opción hace que Ccache ejecute en primer lugar el preprocesador, para posteriormente ejecutar el compilador sobre el código fuente preprocesado, no sobre el original. En teoría esto hace la compilación más rápida, al preprocesar el código fuente sólo una vez. Si queremos hacer uso de esta opción, basta con ejecutar la siguiente variable de entorno antes de compilar un paquete:

$ export CCACHE_NOCPP2=true

Si lo queremos hacer fijo (nada recomendable), editamos el archivo que hemos creado anteriormente, ccache.sh y añadimos lo siguiente, lo que está en rojo:

#!/bin/sh

alias cca="export PATH=/usr/libexec/ccache:$PATH"
export CCACHE_DIR=/.ccache
export CCACHE_UMASK=000
export CCACHE_TEMPDIR=/tmp
export CCACHE_NOCPP2=true

Esta opción da problemas con Clang, cuando se compila código escrito en C++, aumentando el tiempo de compilación un 50 %, con lo que no es nada recomendable su uso, con este compilador. Mi recomendación es crear un alias y ejecutarlo siempre, cuando utilicemos GCC o Clang, este último en las compilaciones de código escrito en C.

#!/bin/sh

alias cca="export PATH=/usr/libexec/ccache:$PATH"
export CCACHE_DIR=/.ccache
export CCACHE_UMASK=000
export CCACHE_TEMPDIR=/tmp
alias ccache-nocpp2="export CCACHE_NOCPP2=true"
alias ccache-cpp2="unset CCACHE_NOCPP2"

Con ccache-nocpp2 hacemos uso de esta opción y con ccache-cpp2, volvemos al funcionamiento por defecto de Ccache.

11) Desactivar la compresión de la caché de Ccache

A partir de la versión 4.0 de Ccache, la compresión de la caché viene activada por defecto, utilizando Zstandard como algoritmo de compresión. Si nuestro procesador no es muy potente, lo más recomendable es desactivarla, aunque el nivel predefinido de compresión utilizado por el programa es relativamente bajo (1 de zstd). Para desactivarla, editamos el archivo que hemos creado anteriormente, ccache.sh y añadimos lo siguiente, lo que está en rojo:

#!/bin/sh

alias cca="export PATH=/usr/libexec/ccache:$PATH"
export CCACHE_DIR=/.ccache
export CCACHE_UMASK=000
export CCACHE_TEMPDIR=/tmp
export CCACHE_NOCOMPRESS=true

Si queremos ver las estadísticas de compresión de la caché, ejecutamos ccache -x en la línea de comandos.

[jose@localhost ~]$ ccache -x
Scanning... 100.0% [===============================================================================]

Total data:              4.1 GB (4.3 GB disk blocks)
Compressed data:         4.1 GB (36.7% of original size)
  - Original data:      11.3 GB
  - Compression ratio: 2.726 x  (63.3% space savings)
Incompressible data:     0.0 kB

12) Mostrar las opciones en curso de Ccache

En cualquier momento, ejecutando el siguiente comando, podemos saber las opciones de Ccache que se están utilizando. Las opciones establecidas mediante variable de entorno, podemos hacerlas fijas, editando el archivo ccache.conf que se encuentra en la raíz del directorio de ubicación que hayamos establecido para Ccache. Un ejemplo:

[jose@localhost ~]$ ccache -p
(default) absolute_paths_in_stderr = false
(default) base_dir =
(environment) cache_dir = /mnt/cache/.ccache
(default) compiler =
(default) compiler_check = mtime
(default) compiler_type = auto
(default) compression = true
(environment) compression_level = -5
(default) cpp_extension =
(default) debug = false
(default) debug_dir =
(default) depend_mode = false
(default) direct_mode = true
(default) disable = false
(default) extra_files_to_hash =
(default) file_clone = false
(default) hard_link = false
(default) hash_dir = true
(default) ignore_headers_in_manifest =
(default) ignore_options =
(default) inode_cache = true
(default) keep_comments_cpp = false
(default) limit_multiple = 0.8
(default) log_file =
(default) max_files = 0
(/mnt/cache/.ccache/ccache.conf) max_size = 30.0G
(default) msvc_dep_prefix = Note: including file:
(default) namespace =
(default) path =
(default) pch_external_checksum = false
(default) prefix_command =
(default) prefix_command_cpp =
(default) read_only = false
(default) read_only_direct = false
(default) recache = false
(default) remote_only = false
(default) remote_storage =
(default) reshare = false
(default) run_second_cpp = true
(/mnt/cache/.ccache/ccache.conf) sloppiness = pch_defines, time_macros
(default) stats = true
(default) stats_log =
(environment) temporary_dir = /tmp
(/mnt/cache/.ccache/ccache.conf) umask = 000

13) Soporte de enlaces de referencia (reflinks) en sistemas de archivos como XFS y BTRFS

A partir de la versión 4.0 de Ccache, se ha incluido el soporte de enlaces de referencia (reflinks) o también conocidos como enlaces COW (copia en escritura). Un enlace de referencia (reflink) es una copia de un archivo similar a un enlace duro (dos directorios apuntan a un mismo inodo), pero a diferencia de este, hay dos entradas de inodo, y son los bloques de datos los que se comparten. Si el archivo clonado se modifica, se añaden más bloques de datos, pero los datos del archivo original se mantienen siempre intactos, evitando que la caché pueda corromperse. Imprescindible la lectura de este enlace para saber las diferencias entre los diferentes tipos de enlaces disponibles en nuestro sistema.

En la caché de Ccache suele haber con bastante frecuencia archivos duplicados, aunque el programa admite también el uso de enlaces duros (CCACHE_HARDLINK=true), el uso de esta opción es más segura para ahorrar espacio en el disco (aunque no se comprima), como se puede comprobar en las estadísticas de compresión que se muestran al final de esta sección.

Para poder hacer uso de esta opción, la caché tiene que estar ubicada en un sistema de archivos XFS o BTRFS y, añadir lo que está en rojo al archivo que hemos creado anteriormente, ccache.sh:

#!/bin/sh

alias cca="export PATH=/usr/libexec/ccache:$PATH"
export CCACHE_DIR=/.ccache
export CCACHE_UMASK=000
export CCACHE_TEMPDIR=/tmp
export CCACHE_FILECLONE=true

Los enlaces de referencia no se pueden comprimir, con lo que, cuando comprobemos los datos comprimidos con el comando ccache -x, éstos aparecerán en el apartado Incompressible data, Un ejemplo personal con la caché ubicada en una partición XFS:

[jose@localhost ~]$ ccache -x
Scanning... 100.0% [===============================================================================]

Total data:              8.6 GB (9.9 GB disk blocks)
Compressed data:         5.6 GB (29.6% of original size)
  - Original data:      18.8 GB
  - Compression ratio: 3.376 x  (70.4% space savings)
Incompressible data:     3.1 GB

Si tenemos pensado hacer uso de esta opción, mi recomendación personal es que se utilice XFS como sistema de archivos, ya que BTRFS tiende a fragmentarse mucho, con el agravante de que, si hacemos uso del desfragmentador que posee este sistema de archivos, los enlaces de referencia se rompen y aumenta de forma considerable el espacio en disco ocupado por los archivos de la caché.

14) Activar el almacenamiento en caché de hashes de archivo según el dispositivo, el inodo y las marcas de tiempo

Esta opción también ha sido incluida partir de la versión 4.0 de Ccache y, en teoría, debería de acelerar el uso de la caché, al reducir el tiempo empleado en hashear los archivos de la misma, pudiendo ser reutilizado en posteriores compilaciones. A partir de la versión 4.7 está activada por defecto, siempre que el sistema de archivos donde está ubicada la caché, lo permita, con lo que ya no es necesario activarla de forma manual.

15) Reducir el nivel de compresión de la caché de Ccache

Si reducimos el nivel de compresión de la caché del programa, aumentaremos la velocidad de compresión y descompresión sin que el tamaño de la caché aumente demasiado. Para establecerla en -5, por ejemplo, añadimos lo que está en rojo al archivo que hemos creado anteriormente, ccache.sh:

#!/bin/sh

alias cca="export PATH=/usr/libexec/ccache:$PATH"
export CCACHE_DIR=/.ccache
export CCACHE_UMASK=000
export CCACHE_TEMPDIR=/tmp
export CCACHE_COMPRESSLEVEL=-5

Posteriormente, recomprimimos la caché existente con el siguiente comando, al nivel establecido en el archivo anterior:

[jose@localhost ~]$ ccache -X -5
Recompressing... 100.0% [==========================================================================]

Original data:           3.2 GB
Old compressed data:     1.3 GB (41.6% of original size)
  - Compression ratio: 2.404 x  (58.4% space savings)
New compressed data:     1.7 GB (51.6% of original size)
  - Compression ratio: 1.940 x  (48.4% space savings)
Size change:          +318.9 MB

16) Saber en todo momento, qué hace Ccache

Esto es útil para comprobar cómo se comporta Ccache en el proceso de compilación. Nos permite también averiguar errores del mismo y saber por ejemplo, si almacena correctamente las cabeceras precompiladas. 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:

#!/bin/sh

alias cca="export PATH=/usr/libexec/ccache:$PATH"
export CCACHE_DIR=/.ccache
export CCACHE_UMASK=000
export CCACHE_TEMPDIR=/tmp
export CCACHE_COMPRESSLEVEL=-5
export CCACHE_COMPILERCHECK=content
alias ccl="export CCACHE_LOGFILE='$HOME/ccache.log'"
alias noccl="export CCACHE_LOGFILE=; rm -f $HOME/ccache.log"

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

17) Obtener las estadísticas de un proceso de compilación concreto

Si queremos obtener las estadísticas de Ccache, en un determinado proceso de compilación, hacemos lo mismo que en el apartado anterior, pero con la correspondiente variable de entorno:

#!/bin/sh

alias cca="export PATH=/usr/libexec/ccache:$PATH"
export CCACHE_DIR=/.ccache
export CCACHE_UMASK=000
export CCACHE_TEMPDIR=/tmp
export CCACHE_COMPRESSLEVEL=-5
alias ccl="export CCACHE_LOGFILE=$HOME/ccache.log"
alias noccl="export CCACHE_LOGFILE=; rm -f $HOME/ccache.log"
alias ccst="export CCACHE_STATSLOG=$HOME/ccache-stats.log"
alias noccst="export CCACHE_STATSLOG=; rm -f $HOME/ccache-stats.log"

Con ccst activamos el archivo de registro de estadísticas en la raíz de nuestro directorio personal, con el nombre ccache-stats.log y con noccst lo desactivamos y borramos el archivo creado.

18) Utilizar un segundo directorio adicional como caché

Aprovechando el soporte de directorios de caché remotos que tiene Ccache, podemos añadir un directorio secundario de caché, ubicado en otro disco duro que tengamos en nuestro sistema. Ccache escribirá los datos en los dos directorios de caché al mismo tiempo (las estadísticas sólo en el principal), aunque lo podemos configurar para que utilice sólo el directorio de caché secundario. ¿Beneficios de utilizar esto? Tener una copia de seguridad de la caché en otro directorio, poder alternar uno u otro según el tamaño de la partición donde cada uno esté ubicado y una ligerísima mejora en los tiempos de compilación, algo un poco absurdo, porque no estamos hablando en ningún momento de un RAID0, pero sí, la ganancia en algunos procesos es evidente, en otros no.

Al archivo anteriormente creado, añadimos lo que está en rojo:

#!/bin/sh

 alias cca="export PATH=/usr/libexec/ccache:$PATH"
export CCACHE_DIR=/.ccache
export CCACHE_UMASK=000
export CCACHE_TEMPDIR=/tmp
export CCACHE_COMPRESSLEVEL=-5
alias ccl="export CCACHE_LOGFILE=$HOME/ccache.log"
alias noccl="export CCACHE_LOGFILE=; rm -f $HOME/ccache.log"
alias ccst="export CCACHE_STATSLOG=$HOME/ccache-stats.log"
alias noccst="export CCACHE_STATSLOG=; rm -f $HOME/ccache-stats.log"
export CCACHE_REMOTE_STORAGE="file:/mnt/cache2/.ccache|umask=000"

La opción umask=000 es requerida para que todos los usuarios del sistema, puedan escribir en dicho directorio. La ubicación del mismo, en el ejemplo, /mnt/cache2, pues donde cada uno lo crea conveniente. Si queremos añadir más directorios de caché, tenemos que separarlos por un espacio, por ejemplo: export CCACHE_REMOTE_STORAGE="file:/mnt/cache2/.ccache|umask=000 file:/mnt/cache3/.ccache|umask=000"

El tamaño de esta caché no se controla de forma automática por Ccache, tenemos que purgarla con el siguiente comando:

$ ccache --trim-max-size 40G --trim-dir /mnt/cache2/.ccache

Con --trim-max-size establecemos el tamaño máximo de la caché, en el ejemplo, 40 GB, y con --trim-dir, la ruta al directorio secundario de la caché.

Si queremos utilizar sólo el directorio secundario como caché (esto tiene más lógica si ese directorio, verdaderamente lo tenemos ubicado en un servidor remoto), añadimos lo que está en rojo, al archivo que estamos utilizando:

#!/bin/sh

 alias cca="export PATH=/usr/libexec/ccache:$PATH"
export CCACHE_DIR=/.ccache
export CCACHE_UMASK=000
export CCACHE_TEMPDIR=/tmp
export CCACHE_COMPRESSLEVEL=-5
alias ccl="export CCACHE_LOGFILE=$HOME/ccache.log"
alias noccl="export CCACHE_LOGFILE=; rm -f $HOME/ccache.log"
alias ccst="export CCACHE_STATSLOG=$HOME/ccache-stats.log"
alias noccst="export CCACHE_STATSLOG=; rm -f $HOME/ccache-stats.log"
export CCACHE_REMOTE_STORAGE="file:/mnt/cache2/.ccache|umask=000"
export CCACHE_REMOTE_ONLY=true


Enlaces


http://ccache.dev >> La web de Ccache.

Foro Galería Blog

Actualizado el 24-07-2024

Compiladores Caché - Ccache

Compiladores Caché - F90cache