c++ - guia - qgis manual

Cómo usar CCache con CMake?

Question

Me gustaría hacer lo siguiente: Si CCache está presente en PATH, use "ccache g ++" para la compilación, de lo contrario use g ++. Traté de escribir un pequeño script my-cmake que contenía

 CC="ccache gcc" CXX="ccache g++" cmake $*

pero parece que no funciona (ejecutar make still no usa ccache; lo comprobé usando CMAKE_VERBOSE_MAKEFILE en).

Actualizar:

Según este enlace intenté cambiar mi script a

 cmake -D CMAKE_CXX_COMPILER="ccache" -D CMAKE_CXX_COMPILER_ARG1="g++" -D CMAKE_C_COMPILER="ccache" -D CMAKE_C_COMPILER_ARG1="gcc" $*

pero cmake se resiste a quejarse de que una prueba falló al usar el ccache del compilador (que puede esperarse).

Answer 1

A partir de CMAKE 3.4, puede hacer:

-DCMAKE_CXX_COMPILER_LAUNCHER=ccache

Answer 2

Ahora es posible especificar ccache como un iniciador para comandos de compilación y comandos de enlace (desde cmake 2.8.0). Eso funciona para el generador de Makefile y Ninja. Para hacer esto, solo establece las siguientes propiedades:

find_program(CCACHE_FOUND ccache)
if(CCACHE_FOUND)
set_property(GLOBAL PROPERTY RULE_LAUNCH_COMPILE ccache)
set_property(GLOBAL PROPERTY RULE_LAUNCH_LINK ccache)
endif(CCACHE_FOUND)

También es posible establecer estas propiedades solo para directorios u objetivos específicos.

Para Ninja, esto es posible desde la versión 3.4. Para XCode, Craig Scott da una solución en su respuesta.

Editar: Gracias a uprego y al comentario de Lekensteyn, edité la respuesta para verificar si ccache está disponible antes de usarlo como iniciador y para qué generadores es posible usar un iniciador de compilación.

Answer 3

Desde CMake 3.1, es posible usar ccache con el generador de Xcode y Ninja es compatible con CMake 3.4 en adelante. Ninja honrará a RULE_LAUNCH_COMPILE al igual que el generador de Makefiles de Unix (para que la respuesta de @Babcool también te lleve allí para Ninja), pero conseguir ccache trabajando para el generador de Xcode requiere un poco más de trabajo. El siguiente artículo explica el método en detalle, centrándose en una implementación general que funciona para los tres generadores CMake y no hace suposiciones sobre la configuración de los enlaces simbólicos de caché o el compilador subyacente utilizado (todavía le permite a CMake decidir el compilador):

https://crascit.com/2016/04/09/using-ccache-with-cmake/

La esencia general del artículo es la siguiente. El inicio de su archivo CMakeLists.txt debe configurarse de la siguiente manera:

cmake_minimum_required(VERSION 2.8)
find_program(CCACHE_PROGRAM ccache)
if(CCACHE_PROGRAM)
# Support Unix Makefiles and Ninja
set_property(GLOBAL PROPERTY RULE_LAUNCH_COMPILE "${CCACHE_PROGRAM}")
endif()
project(SomeProject)
get_property(RULE_LAUNCH_COMPILE GLOBAL PROPERTY RULE_LAUNCH_COMPILE)
if(RULE_LAUNCH_COMPILE AND CMAKE_GENERATOR STREQUAL "Xcode")
# Set up wrapper scripts
configure_file(launch-c.in launch-c)
configure_file(launch-cxx.in launch-cxx)
execute_process(COMMAND chmod a+rx
"${CMAKE_BINARY_DIR}/launch-c"
"${CMAKE_BINARY_DIR}/launch-cxx")
# Set Xcode project attributes to route compilation through our scripts
set(CMAKE_XCODE_ATTRIBUTE_CC "${CMAKE_BINARY_DIR}/launch-c")
set(CMAKE_XCODE_ATTRIBUTE_CXX "${CMAKE_BINARY_DIR}/launch-cxx")
set(CMAKE_XCODE_ATTRIBUTE_LD "${CMAKE_BINARY_DIR}/launch-c")
set(CMAKE_XCODE_ATTRIBUTE_LDPLUSPLUS "${CMAKE_BINARY_DIR}/launch-cxx")
endif()

Los dos archivos de plantilla de script launch-c.in y launch-cxx.in ven así (deben estar en el mismo directorio que el archivo CMakeLists.txt ):

launch-c.in:

#!/bin/sh
export CCACHE_CPP2=true
exec "${RULE_LAUNCH_COMPILE}" "${CMAKE_C_COMPILER}" "$@"

launch-cxx.in:

#!/bin/sh
export CCACHE_CPP2=true
exec "${RULE_LAUNCH_COMPILE}" "${CMAKE_CXX_COMPILER}" "$@"

Lo anterior usa RULE_LAUNCH_COMPILE solo para Unix Makefiles y Ninja, pero para el generador Xcode depende de la ayuda del CMAKE_XCODE_ATTRIBUTE_... soporte de variables de CMake. La configuración de los atributos Xcode definidos por el usuario CC y CXX para controlar el comando del compilador y LD y LDPLUSPLUS para el comando del enlazador no es, hasta donde puedo decir, una característica documentada de los proyectos Xcode, pero parece funcionar. Si alguien puede confirmar que es oficialmente compatible con Apple, actualizaré el artículo vinculado y esta respuesta en consecuencia.

Answer 4

En mi opinión, la mejor manera es enlazar gcc, g ++ a ccache, pero si desea usar dentro de cmake, intente esto:

export CC="ccache gcc" CXX="ccache g++" cmake ...

Answer 5

No me gustaba establecer un enlace simbólico de g++ a ccache . Y CXX="ccache g++" no funcionó para mí, ya que algunos casos de prueba de cmake querían tener solo el programa de compilación sin atributos.

Así que usé un pequeño script bash en su lugar:

#!/bin/bash
ccache g++ "$@"

y lo guardó como un ejecutable en /usr/bin/ccache-g++ .

Luego C configuró cmake para usar /usr/bin/ccache-g++ como compilador de C ++. De esta manera pasa los casos de prueba de cmake y me siento más cómodo que tener enlaces simbólicos que podría olvidar en 2 o 3 semanas y luego quizás me pregunte si algo no funciona ...

Answer 6

Permítanme agregar un elemento importante que no se mencionó aquí antes.

Al realizar un arranque de un sistema de compilación minimalista a partir de la imagen ubunutu: docking 18.04, descubrí que el orden de instalación marca la diferencia.

En mi caso, ccache funcionó bien al llamar a gcc , pero no capturó las invocaciones del mismo compilador con los otros nombres: cc y c++ . Para instalar completamente ccache, debe asegurarse de que todos los compiladores estén instalados primero, o agregar una llamada a los enlaces simbólicos update-ccache para que estén seguros.

sudo apt-get install ccache build-essential # and everyhting ... sudo /usr/sbin/update-ccache-symlinks export PATH="/usr/lib/ccache/:$PATH"

... y luego (debido a los enlaces simbólicos actualizados) también se atrapan las llamadas a cc y c ++

Answer 7

Personalmente tengo /usr/lib/ccache en mi $PATH . Este directorio contiene montones de enlaces simbólicos para cada nombre posible desde el que se puede invocar al compilador (como gcc y gcc-4.3 ), todos apuntando a ccache.

Y ni siquiera creé los enlaces simbólicos. Ese directorio viene prellenado cuando instalo ccache en Debian.

Answer 8

Verifiqué los siguientes trabajos (fuente: este enlace ):

 CC="gcc" CXX="g++" cmake -D CMAKE_CXX_COMPILER="ccache" -D CMAKE_CXX_COMPILER_ARG1="g++" -D CMAKE_C_COMPILER="ccache" -D CMAKE_C_COMPILER_ARG1="gcc" $*

Actualización : más tarde me di cuenta de que incluso esto no funciona. Extrañamente funciona cada vez que se alterna (las otras veces cmake se queja).