web-dev-qa-db-fra.com

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 (exécuter make n'utilise toujours pas ccache; j'ai vérifié cela en utilisant CMAKE_VERBOSE_MAKEFILE) 

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

c++unixcmakeccache
77
amit

J'ai personnellement /usr/lib/ccache dans mon $PATH. Ce répertoire contient des charges de liens symboliques pour chaque nom possible à partir duquel le compilateur pourrait être appelé (comme gcc et 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.

58
Nicolás

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 le générateur Ninja. 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)
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: Merci aux commentaires d’uprego et de Lekensteyn, j’ai modifié 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.

80
Babcool

A partir de CMAKE 3.4, vous pouvez faire: 

-DCMAKE_CXX_COMPILER_LAUNCHER=ccache
59
Jacob

Je n'ai pas aimé définir un lien symbolique de g++ à ccache. Et CXX="ccache g++" ne fonctionnait pas pour moi, car certains cas de test de cmake ne voulaient avoir que le programme de compilation sans attributs.

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

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

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

Ensuite, C a configuré cmake pour utiliser /usr/bin/ccache-g++ en tant que compilateur C++ . Ainsi, il réussit les cas de test 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 se demander ensuite si quelque chose ne fonctionne pas. ...

8
jonas

Depuis 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 respectera RULE_LAUNCH_COMPILE tout comme le générateur de Makefiles Unix (donc la réponse de @Babcool vous y amène également pour Ninja), mais faire fonctionner ccache pour le générateur de 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 de CMake et ne fait aucune hypothèse sur la configuration des liens symboliques ccache ou du compilateur sous-jacent utilisé (il laisse toujours CMake choisir le compilateur):

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

L’essentiel de l’article est le suivant. Le début de votre fichier CMakeLists.txt devrait ê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èle de script launch-c.in et 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}" "$@"

Ce qui précède utilise RULE_LAUNCH_COMPILE seul pour Unix Makefiles et Ninja, mais pour le générateur Xcode, il s’appuie sur l’aide du support des variables CMAKE_XCODE_ATTRIBUTE_... de CMake. La définition des attributs Xcode définis par l'utilisateur CC et CXX pour contrôler la commande du compilateur et des variables LD et LDPLUSPLUS pour la commande de l'éditeur de liens n'est pas, à ce que je sache, documentée, mais elle semble fonctionner. 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.

7
Craig Scott

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é par la suite que même cela ne fonctionnait pas. Étrangement, cela fonctionne à chaque fois (les autres fois, cmake se plaint). 

6
amit

A mon avis, le meilleur moyen est de faire un lien symbolique avec gcc, g ++ vers ccache, mais si vous souhaitez utiliser dans cmake, essayez ceci:

export CC="ccache gcc" CXX="ccache g++" cmake ...
4
Nadir SOUALEM