Comment utiliser CCache avec CMake ?

Question

Je voudrais faire ce qui suit : Si CCache est présent dans le PATH, utiliser "ccache g++" pour la compilation, sinon utiliser g++. J'ai essayé d'écrire un petit my-cmake script contenant

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

mais cela ne semble pas fonctionner (l'exécution de make n'utilise toujours pas ccache ; j'ai vérifié cela en utilisant CMAKE_VERBOSE_MAKEFILE on).

Mise à jour :

Conformément à la ce lien J'ai essayé de changer mon script en

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

mais cmake s'arrête en se plaignant qu'un test a échoué lors de l'utilisation du ccache du compilateur (ce qui est prévisible).

Answer 1

Depuis CMAKE 3.4, vous pouvez le faire :

-DCMAKE_CXX_COMPILER_LAUNCHER=ccache

Answer 2

Il est maintenant possible de spécifier ccache comme lanceur pour les commandes de compilation et de liaison (depuis cmake 2.8.0). Cela fonctionne pour Makefile et le générateur Ninja. Pour cela, il suffit de définir les propriétés suivantes :

find_program(CCACHE_FOUND ccache)
if(CCACHE_FOUND)
    set_property(GLOBAL PROPERTY RULE_LAUNCH_COMPILE ccache)
    set_property(GLOBAL PROPERTY RULE_LAUNCH_LINK ccache) # Less useful to do it for linking, see edit2
endif(CCACHE_FOUND)

Il est également possible de définir ces propriétés uniquement pour des répertoires ou des cibles spécifiques.

Pour Ninja, c'est possible depuis la version 3.4. Pour XCode, Craig Scott donne une solution de contournement dans sa réponse.

Edit : Grâce à uprego et au commentaire de Lekensteyn, j'ai édité la réponse pour vérifier si ccache est disponible avant de l'utiliser comme lanceur et pour quels générateurs est-il possible d'utiliser un lanceur de compilation.

Edit2 : @Emilio Cobos recommande d'éviter de faire cela pour la partie linking car ccache n'améliore pas la vitesse de linking et peut perturber d'autres types de cache comme sccache.

Answer 3

J'ai personnellement /usr/lib/ccache dans mon $PATH . Ce répertoire contient des tas de liens symboliques pour tous les noms possibles à partir desquels le compilateur peut être appelé (comme gcc y gcc-4.3 ), pointant tous vers ccache.

Et je n'ai même pas créé les liens symboliques. Ce répertoire est pré-rempli lorsque j'installe ccache sous Debian.

Answer 4

Depuis CMake 3.1, il est possible d'utiliser ccache avec le générateur Xcode et Ninja est supporté à partir de CMake 3.4. Ninja respectera RULE_LAUNCH_COMPILE tout comme le générateur Unix Makefiles (la réponse de @Babcool vous y conduit également pour Ninja), mais faire fonctionner ccache pour le générateur Xcode demande un peu plus de travail. L'article suivant explique la méthode en détail, en se concentrant sur une implémentation générale qui fonctionne pour les trois générateurs CMake et en ne faisant aucune hypothèse sur la configuration des liens symboliques ccache ou sur le compilateur sous-jacent utilisé (il laisse toujours CMake décider du compilateur) :

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

L'essentiel de l'article est le suivant. Le début de votre CMakeLists.txt doit être configuré de la manière suivante :

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()

Les deux fichiers de modèles script launch-c.in y launch-cxx.in ressemblent à ceci (ils doivent se trouver dans le même répertoire que le fichier 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}" "$@"

Les utilisations ci-dessus RULE_LAUNCH_COMPILE pour les Makefiles Unix et Ninja, mais pour le générateur Xcode, il s'appuie sur l'aide de l'outil CMake CMAKE_XCODE_ATTRIBUTE_... soutien aux variables. Le réglage des CC y CXX des attributs Xcode définis par l'utilisateur pour contrôler la commande du compilateur et les attributs Xcode définis par l'utilisateur. LD y LDPLUSPLUS pour la commande linker n'est pas, pour autant que je sache, une fonctionnalité documentée des projets Xcode, mais cela semble fonctionner. Si quelqu'un peut confirmer qu'elle est officiellement supportée par Apple, je mettrai à jour l'article lié et cette réponse en conséquence.

Answer 5

Je n'aimais pas mettre en place un lien symbolique à partir de g++ a ccache . Et CXX="ccache g++" n'a pas fonctionné pour moi car certains tests de cmake voulaient avoir seulement le programme du compilateur sans les attributs.

J'ai donc utilisé un petit script bash script à la place :

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

et l'a enregistré en tant qu'exécutable dans /usr/bin/ccache-g++ .

Ensuite, C a configuré cmake pour qu'il utilise /usr/bin/ccache-g++ comme compilateur C++. De cette façon, il passe les tests de cmake et je me sens plus à l'aise que d'avoir des liens symboliques que je pourrais oublier dans 2 ou 3 semaines et me demander si quelque chose ne fonctionne pas...