Comment utiliser CCache avec CMake?

Je voudrais faire ce qui suit: Si CCache est présent dans PATH, utilisez "ccache g ++" pour la compilation, sinon utilisez g ++. J'ai essayé d'écrire un petit script my-cmake 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 sur).

Mise à jour:

Selon 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 renonce à se plaindre qu'un test a échoué lors de l'utilisation du compilateur ccache (ce à quoi on peut s'attendre).

J'ai personnellement /usr/lib/ccachedans mon $PATH. Ce répertoire contient des tas de liens symboliques pour chaque nom possible à partir duquel le compilateur pourrait être appelé (comme gccet gcc-4.3), tous pointant vers ccache.

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

Il est maintenant possible de spécifier ccache comme lanceur pour les commandes de compilation et les commandes de lien (depuis cmake 2.8.0). Cela fonctionne pour Makefile et Ninja Generator. Pour ce faire, définissez simplement 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, cela est possible depuis la version 3.4. Pour XCode, Craig Scott donne une solution de contournement dans sa réponse.

Edit: Grâce au commentaire d'uprego et 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 a recommandé d'éviter de faire cela pour la partie de liaison car ccache n'améliore pas la vitesse de liaison et peut gâcher d'autres types de cache comme sccache

Depuis CMAKE 3.4, vous pouvez faire:

-DCMAKE_CXX_COMPILER_LAUNCHER=ccache

A partir de CMake 3.1, il est possible d'utiliser ccache avec le générateur Xcode et Ninja est pris en charge à partir de CMake 3.4. Ninja honorera RULE_LAUNCH_COMPILEtout comme le générateur Unix Makefiles (donc la réponse de @ Babcool vous y conduit aussi pour Ninja), mais faire fonctionner le cache 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 du compilateur sous-jacent utilisé (il laisse toujours CMake décider du compilateur):

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

L'essentiel général de l'article est le suivant. Le début de votre CMakeLists.txtfichier doit être configuré comme ceci:

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èle de script launch-c.inet launch-cxx.inressemblent à ceci (ils doivent être dans le même répertoire que le CMakeLists.txtfichier):

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}" "$@"

Ce qui précède est utilisé RULE_LAUNCH_COMPILEseul pour Unix Makefiles et Ninja, mais pour le générateur Xcode, il repose sur l'aide du CMAKE_XCODE_ATTRIBUTE_...support des variables de CMake . Le réglage des CCet CXXattributs de contrôle définis par l' utilisateur Xcode la commande du compilateur et LDet LDPLUSPLUSpour la commande de liaison est pas, pour autant que je peux dire, une caractéristique documentée des projets Xcode, mais il ne semble travailler. Si quelqu'un peut confirmer qu'il est officiellement pris en charge par Apple, je mettrai à jour l'article lié et cette réponse en conséquence.

Je n'aimais pas définir un lien symbolique de g++à ccache. Et cela CXX="ccache g++"n'a pas fonctionné pour moi car certains cas de test cmake voulaient avoir juste le programme de compilation sans attributs.

J'ai donc utilisé un petit script bash à 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 l'utiliser /usr/bin/ccache-g++comme compilateur C ++. De cette façon, cela passe les cas de test cmake et je me sens plus à l'aise que d'avoir des liens symboliques que je pourrais oublier dans 2 ou 3 semaines et ensuite peut-être me demander si quelque chose ne fonctionne pas ...

À mon avis, le meilleur moyen est de créer un lien symbolique gcc, g ++ vers ccache, mais si vous souhaitez utiliser dans cmake, essayez ceci:

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

J'ai vérifié les travaux suivants (source: ce lien ):

        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" $*

Mise à jour : j'ai réalisé plus tard que même cela ne fonctionnait pas. Curieusement, cela fonctionne à chaque fois (les autres fois, cmake se plaint).

Permettez-moi d’ajouter un élément important qui n’a pas été mentionné auparavant.

Lors du démarrage d'un système de construction minimaliste à partir de l'image docker ubunutu: 18.04, j'ai trouvé que l'ordre d'installation fait une différence.

Dans mon cas, ccache a bien fonctionné lors de l'appel gcc, mais n'a pas réussi à intercepter les appels du même compilateur par les autres noms: ccet c++. Pour installer complètement ccache, vous devez vous assurer que tous les compilateurs sont installés en premier, ou ajouter un appel aux liens symboliques update-ccache pour être sûr.

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

... puis (en raison des liens symboliques mis à jour), les appels à cc et c ++ sont également pris!